Revert of default SkPixelSerializer (patchset #1 id:1 of https://codereview.chromium.org/1507123002/ )

Reason for revert:
Breaking DEPS roll (linker error)

Original issue's description:
> default SkPixelSerializer
>
> Add SkImageEncoder::EncodeData(const SkPixmap&, ...) function.
>
> Add SkImageEncoder::CreatePixelSerializer() to return a
> PixelSerializer that calls into SkImageEncoder::EncodeData.
>
> SkImage::encode() make use of SkImageEncoder::CreatePixelSerializer.
>
> Committed: https://skia.googlesource.com/skia/+/b0bd1516bff3f5afcbfd615e805867531657811b

TBR=scroggo@google.com,halcanary@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1505203003

debugger/QT/SkDebuggerGUI.cpp

@@ -281,9 +281,8 @@ void SkDebuggerGUI::saveToFile(const SkString& filename) {
     SkFILEWStream file(filename.c_str());
     SkAutoTUnref<SkPicture> copy(fDebugger.copyPicture());
 
-    SkAutoTUnref<SkPixelSerializer> serializer(
-            SkImageEncoder::CreatePixelSerializer());
-    copy->serialize(&file, serializer);
+    sk_tool_utils::PngPixelSerializer serializer;
+    copy->serialize(&file, &serializer);
 }
 
 void SkDebuggerGUI::loadFile(QListWidgetItem *item) {

include/core/SkImageEncoder.h

@@ -12,8 +12,6 @@
 #include "SkTRegistry.h"
 
 class SkBitmap;
-class SkPixelSerializer;
-class SkPixmap;
 class SkData;
 class SkWStream;
 
@@ -66,17 +64,11 @@ public:
                               Type, int quality);
     static SkData* EncodeData(const SkBitmap&, Type, int quality);
 
-    static SkData* EncodeData(const SkPixmap&, Type, int quality);
-
     static bool EncodeFile(const char file[], const SkBitmap&, Type,
                            int quality);
     static bool EncodeStream(SkWStream*, const SkBitmap&, Type,
                            int quality);
 
-    /** Uses SkImageEncoder to serialize images that are not already
-        encoded as SkImageEncoder::kPNG_Type images. */
-    static SkPixelSerializer* CreatePixelSerializer();
-
 protected:
     /**
      * Encode bitmap 'bm' in the desired format, writing results to

src/image/SkImage.cpp

@@ -9,7 +9,6 @@
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkData.h"
-#include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkImageShader.h"
@@ -179,14 +178,32 @@ SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {
     return nullptr;
 }
 
-SkData* SkImage::encode(SkPixelSerializer* serializer) const {
-    SkAutoTUnref<SkPixelSerializer> defaultSerializer;
-    SkPixelSerializer* effectiveSerializer = serializer;
-    if (!effectiveSerializer) {
-        defaultSerializer.reset(SkImageEncoder::CreatePixelSerializer());
-        SkASSERT(defaultSerializer.get());
-        effectiveSerializer = defaultSerializer.get();
+namespace {
+
+class DefaultSerializer :  public SkPixelSerializer {
+protected:
+    bool onUseEncodedData(const void *data, size_t len) override {
+        return true;
     }
+    SkData* onEncode(const SkPixmap& pixmap) override {
+        SkBitmap bm;
+        if (!bm.installPixels(pixmap.info(),
+                              const_cast<void*>(pixmap.addr()),
+                              pixmap.rowBytes(),
+                              pixmap.ctable(),
+                              nullptr, nullptr)) {
+            return nullptr;
+        }
+        return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
+    }
+};
+
+} // anonymous namespace
+
+SkData* SkImage::encode(SkPixelSerializer* serializer) const {
+    DefaultSerializer defaultSerializer;
+    SkPixelSerializer* effectiveSerializer = serializer ? serializer : &defaultSerializer;
+
     SkAutoTUnref<SkData> encoded(this->refEncoded());
     if (encoded && effectiveSerializer->useEncodedData(encoded->data(), encoded->size())) {
         return encoded.detach();

src/images/SkImageEncoder.cpp

@@ -7,8 +7,6 @@
 
 #include "SkImageEncoder.h"
 #include "SkBitmap.h"
-#include "SkPixelSerializer.h"
-#include "SkPixmap.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 
@@ -59,33 +57,6 @@ SkData* SkImageEncoder::EncodeData(const SkImageInfo& info, const void* pixels,
     if (!bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {
         return nullptr;
     }
-    bm.setImmutable();
-    return SkImageEncoder::EncodeData(bm, t, quality);
-}
-
-SkData* SkImageEncoder::EncodeData(const SkPixmap& pixmap,
-                                   Type t, int quality) {
-    SkBitmap bm;
-    if (!bm.installPixels(pixmap.info(),
-                          const_cast<void*>(pixmap.addr()),
-                          pixmap.rowBytes(),
-                          pixmap.ctable(), nullptr, nullptr)) {
-        return nullptr;
-    }
-    bm.setImmutable();
-    return SkImageEncoder::EncodeData(bm, t, quality);
-}
-
-namespace {
-class ImageEncoderPixelSerializer final : public SkPixelSerializer {
-protected:
-    bool onUseEncodedData(const void*, size_t) override { return true; }
-    SkData* onEncode(const SkPixmap& pmap) override {
-        return SkImageEncoder::EncodeData(pmap, SkImageEncoder::kPNG_Type, 100);
-    }
-};
-} // namespace
-
-SkPixelSerializer* SkImageEncoder::CreatePixelSerializer() {
-    return new ImageEncoderPixelSerializer;
+    SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t));
+    return enc.get() ? enc.get()->encodeData(bm, quality) : nullptr;
 }

tests/PictureTest.cpp

@@ -851,9 +851,8 @@ static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     SkDynamicMemoryWStream wStream;
-    SkAutoTUnref<SkPixelSerializer> serializer(
-            SkImageEncoder::CreatePixelSerializer());
-    picture->serialize(&wStream, serializer);
+    sk_tool_utils::PngPixelSerializer serializer;
+    picture->serialize(&wStream, &serializer);
     return wStream.copyToData();
 }
 

tools/sk_tool_utils.h

@@ -114,6 +114,18 @@ namespace sk_tool_utils {
     SkBitmap create_string_bitmap(int w, int h, SkColor c, int x, int y,
                                   int textSize, const char* str);
 
+    // Encodes to PNG, unless there is already encoded data, in which case that gets
+    // used.
+    class PngPixelSerializer : public SkPixelSerializer {
+    public:
+        bool onUseEncodedData(const void*, size_t) override { return true; }
+        SkData* onEncodePixels(const SkImageInfo& info, const void* pixels,
+                               size_t rowBytes) override {
+            return SkImageEncoder::EncodeData(info, pixels, rowBytes,
+                                              SkImageEncoder::kPNG_Type, 100);
+        }
+    };
+
     // A helper for inserting a drawtext call into a SkTextBlobBuilder
     void add_to_text_blob(SkTextBlobBuilder* builder, const char* text, const SkPaint& origPaint,
                           SkScalar x, SkScalar y);