Deserialize pictures with custom image-deserializer

src/core/SkPicture.cpp

 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAtomics.h"
 #include "SkImageGenerator.h"
 #include "SkMessageBus.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkPictureRecorder.h"
 
 #if defined(SK_DISALLOW_CROSSPROCESS_PICTUREIMAGEFILTERS) || \
     defined(SK_ENABLE_PICTURE_IO_SECURITY_PRECAUTIONS)
 static bool g_AllPictureIOSecurityPrecautionsEnabled = true;
 #else
 static bool g_AllPictureIOSecurityPrecautionsEnabled = false;
 #endif
 
 DECLARE_SKMESSAGEBUS_MESSAGE(SkPicture::DeletionMessage);
 
+class DefaultImageDeserializer : public SkImageDeserializer {
+public:
+    sk_sp<SkImage> deserialize(sk_sp<SkData> encoded, const SkIRect* subset) override {
+        return SkImage::MakeFromEncoded(std::move(encoded), subset);
+    }
+};
+
+class InstallProcImageDeserializer : public SkImageDeserializer {
+    SkPicture::InstallPixelRefProc fProc;
+public:
+    InstallProcImageDeserializer(SkPicture::InstallPixelRefProc proc) : fProc(proc) {}
+
+    sk_sp<SkImage> deserialize(sk_sp<SkData> encoded, const SkIRect* subset) override {
+        SkBitmap bitmap;
+        if (fProc(encoded->data(), encoded->size(), &bitmap)) {
+            return SkImage::MakeFromBitmap(bitmap);

[f(malita), 2016/07/26 21:29:43]

bitmap.setImmutable first to avoid a copy?

[reed1, 2016/07/29 13:12:04]

Done.

+        }
+        return nullptr;
+    }
+};
+
 /* SkPicture impl.  This handles generic responsibilities like unique IDs and serialization. */
 
 SkPicture::SkPicture() : fUniqueID(0) {}
 
 SkPicture::~SkPicture() {
     // TODO: move this to ~SkBigPicture() only?
 
     // If the ID is still zero, no one has read it, so no need to send this message.
     uint32_t id = sk_atomic_load(&fUniqueID, sk_memory_order_relaxed);
     if (id != 0) {
@@ skipping 98 matching lines @@
                                         const SkReadBuffer* buffer) {
     if (!data) {
         return nullptr;
     }
     SkPicturePlayback playback(data);
     SkPictureRecorder r;
     playback.draw(r.beginRecording(info.fCullRect), nullptr/*no callback*/, buffer);
     return r.finishRecordingAsPicture();
 }
 
+#ifdef SK_SUPPORT_LEGACY_PICTUREINSTALLPIXELREF
 static bool default_install(const void* src, size_t length, SkBitmap* dst) {
     sk_sp<SkData> encoded(SkData::MakeWithCopy(src, length));
     return encoded && SkDEPRECATED_InstallDiscardablePixelRef(
             SkImageGenerator::NewFromEncoded(encoded.get()), dst);
 }
-
-sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream) {
-    return MakeFromStream(stream, &default_install, nullptr);
-}
-
 sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream, InstallPixelRefProc proc) {
     return MakeFromStream(stream, proc, nullptr);
 }
+#endif
 
-sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream, InstallPixelRefProc proc,
+sk_sp<SkPicture> SkPicture::MakeFromStreamWithDeserializer(SkStream* stream,
+                                                           SkImageDeserializer* factory) {
+    return MakeFromStream(stream, factory, nullptr);
+}
+
+sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream) {
+    DefaultImageDeserializer factory;
+    return MakeFromStreamWithDeserializer(stream, &factory);
+}
+
+sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream, SkImageDeserializer* factory,
                                            SkTypefacePlayback* typefaces) {
     SkPictInfo info;
     if (!InternalOnly_StreamIsSKP(stream, &info) || !stream->readBool()) {
         return nullptr;
     }
     SkAutoTDelete<SkPictureData> data(
-            SkPictureData::CreateFromStream(stream, info, proc, typefaces));
+            SkPictureData::CreateFromStream(stream, info, factory, typefaces));
     return Forwardport(info, data, nullptr);
 }
 
 sk_sp<SkPicture> SkPicture::MakeFromBuffer(SkReadBuffer& buffer) {
     SkPictInfo info;
     if (!InternalOnly_BufferIsSKP(&buffer, &info) || !buffer.readBool()) {
         return nullptr;
     }
     SkAutoTDelete<SkPictureData> data(SkPictureData::CreateFromBuffer(buffer, info));
     return Forwardport(info, data, &buffer);
@@ skipping 54 matching lines @@
 #endif
 
 // Global setting to disable security precautions for serialization.
 void SkPicture::SetPictureIOSecurityPrecautionsEnabled_Dangerous(bool set) {
     g_AllPictureIOSecurityPrecautionsEnabled = set;
 }
 
 bool SkPicture::PictureIOSecurityPrecautionsEnabled() {
     return g_AllPictureIOSecurityPrecautionsEnabled;
 }