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

Committed: https://skia.googlesource.com/skia/+/808ce2886d732b1055f89c8fb0f1b11b47fcb0ce

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

debugger/QT/SkDebuggerGUI.cpp

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

include/core/SkImageEncoder.h

@@ -12,6 +12,8 @@
 #include "SkTRegistry.h"
 
 class SkBitmap;
+class SkPixelSerializer;
+class SkPixmap;
 class SkData;
 class SkWStream;
 
@@ -64,11 +66,17 @@ 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,6 +9,7 @@
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkData.h"
+#include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkImageShader.h"
@@ -178,32 +179,14 @@ SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {
     return nullptr;
 }
 
-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;
+    SkAutoTUnref<SkPixelSerializer> defaultSerializer;
-    SkPixelSerializer* effectiveSerializer = serializer ? serializer : &defaultSerializer;
+    SkPixelSerializer* effectiveSerializer = serializer;
-
+    if (!effectiveSerializer) {
+        defaultSerializer.reset(SkImageEncoder::CreatePixelSerializer());
+        SkASSERT(defaultSerializer.get());
+        effectiveSerializer = defaultSerializer.get();
+    }
     SkAutoTUnref<SkData> encoded(this->refEncoded());
     if (encoded && effectiveSerializer->useEncodedData(encoded->data(), encoded->size())) {
         return encoded.detach();

src/images/SkImageEncoder.cpp

@@ -7,6 +7,8 @@
 
 #include "SkImageEncoder.h"
 #include "SkBitmap.h"
+#include "SkPixelSerializer.h"
+#include "SkPixmap.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 
@@ -57,6 +59,30 @@ SkData* SkImageEncoder::EncodeData(const SkImageInfo& info, const void* pixels,
     if (!bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {
         return nullptr;
     }
-    SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t));
+    bm.setImmutable();
-    return enc.get() ? enc.get()->encodeData(bm, quality) : nullptr;
+    return SkImageEncoder::EncodeData(bm, t, quality);
+}
+
+SkData* SkImageEncoder::EncodeData(const SkPixmap& pixmap,
+                                   Type t, int quality) {
+    SkBitmap bm;
+    if (!bm.installPixels(pixmap)) {
+        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;
 }

src/ports/SkImageDecoder_empty.cpp

@@ -11,6 +11,7 @@
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkMovie.h"
+#include "SkPixelSerializer.h"
 #include "SkStream.h"
 
 class SkColorTable;
@@ -108,6 +109,10 @@ SkData* SkImageEncoder::EncodeData(const SkImageInfo&, const void* pixels, size_
     return nullptr;
 }
 
+SkData* SkImageEncoder::EncodeData(const SkPixmap&, Type, int) {
+    return nullptr;
+}
+
 bool SkImageEncoder::encodeStream(SkWStream*, const SkBitmap&, int) {
     return false;
 }
@@ -119,4 +124,17 @@ SkData* SkImageEncoder::encodeData(const SkBitmap&, int) {
 bool SkImageEncoder::encodeFile(const char file[], const SkBitmap& bm, int quality) {
     return false;
 }
+
+namespace {
+class ImageEncoderPixelSerializer final : public SkPixelSerializer {
+protected:
+    bool onUseEncodedData(const void*, size_t) override { return true; }
+    SkData* onEncode(const SkPixmap&) override { return nullptr; }
+};
+}  // namespace
+
+SkPixelSerializer* SkImageEncoder::CreatePixelSerializer() {
+    return new ImageEncoderPixelSerializer;
+}
+
 /////////////////////////////////////////////////////////////////////////

tests/PictureTest.cpp

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

tools/sk_tool_utils.cpp

@@ -222,19 +222,6 @@ SkBitmap create_string_bitmap(int w, int h, SkColor c, int x, int y,
     return bitmap;
 }
 
-bool PngPixelSerializer::onUseEncodedData(const void*, size_t) { return true; }
-SkData* PngPixelSerializer::onEncode(const SkPixmap& pixmap) {
-    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);
-}
-
 void add_to_text_blob(SkTextBlobBuilder* builder, const char* text, const SkPaint& origPaint,
                       SkScalar x, SkScalar y) {
     SkPaint paint(origPaint);

tools/sk_tool_utils.h

@@ -114,14 +114,6 @@ 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;
-        SkData* onEncode(const SkPixmap&) override;
-    };
-
     // 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);