change write-image to use pipeverbs like everyone else, and add test

src/pipe/SkPipeReader.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDeduper.h"
 #include "SkPicture.h"
@@ skipping 671 matching lines @@
 }
 
 static sk_sp<SkImage> make_from_encoded(const sk_sp<SkData>& data) {
     sk_sp<SkImage> image = make_from_skiaimageformat(data->data(), data->size());
     if (!image) {
         image = SkImage::MakeFromEncoded(data);
     }
     return image;
 }
 
-static void defineImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+static void defineImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas*) {
     SkASSERT(SkPipeVerb::kDefineImage == unpack_verb(packedVerb));
     SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
     uint32_t extra = unpack_verb_extra(packedVerb);
     int index = extra & kIndex_ObjectDefinitionMask;
 
     if (extra & kUndef_ObjectDefinitionMask) {
         // zero-index means we are "forgetting" that cache entry
         inflator->setImage(index, nullptr);
     } else {
         // we are defining a new image
@@ skipping 157 matching lines @@
     memcpy(&cull, data, sizeof(SkRect));
     size -= sizeof(SkRect); data = (const char*)data + sizeof(SkRect);
 
     SkPictureRecorder recorder;
     this->playback(data, size, recorder.beginRecording(cull));
     return recorder.finishRecordingAsPicture();
 }
 
 sk_sp<SkImage> SkPipeDeserializer::readImage(const void* data, size_t size) {
     if (size < sizeof(uint32_t)) {
+        SkDebugf("-------- data length too short for readImage %d\n", size);
         return nullptr;
     }
 
-    uint32_t header;
-    memcpy(&header, data, 4); size -= 4; data = (const char*)data + 4;
-    if (kDefineImage_ExtPipeVerb != header) {
-        return nullptr;
+    const uint32_t* ptr = (const uint32_t*)data;
+    uint32_t packedVerb = *ptr++;
+    size -= 4;
+
+    switch (unpack_verb(packedVerb)) {
+        case SkPipeVerb::kWriteImage:
+            break;
+        case SkPipeVerb::kDefineImage: {
+            SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
+                                    &fImpl->fTypefaces, &fImpl->fFactories,
+                                    fImpl->fTFDeserializer);
+            SkPipeReader reader(this, ptr, size);
+            reader.setInflator(&inflator);
+            defineImage_handler(reader, packedVerb, nullptr);
+        } break;
+        default:
+            SkDebugf("-------- unexpected verb for readImage %d\n", unpack_verb(packedVerb));
+            return nullptr;
     }
-
-    SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
-                            &fImpl->fTypefaces, &fImpl->fFactories,
-                            fImpl->fTFDeserializer);
-    SkPipeReader reader(this, data, size);
-    reader.setInflator(&inflator);
-    return sk_sp<SkImage>(reader.readImage());
+    int index = unpack_verb_extra(packedVerb);
+    if (0 == index) {
+        return nullptr; // writer failed
+    }
+    return sk_ref_sp(fImpl->fImages.get(index - 1));
 }
 
 static bool do_playback(SkPipeReader& reader, SkCanvas* canvas, int* endPictureIndex) {
     int indent = 0;
 
-    const bool showEachVerb = false;
+    const bool showEachVerb = true;
     int counter = 0;
     while (!reader.eof()) {
         uint32_t prevOffset = reader.offset();
         uint32_t packedVerb = reader.read32();
         SkPipeVerb verb = unpack_verb(packedVerb);
         if ((unsigned)verb >= SK_ARRAY_COUNT(gPipeHandlers)) {
             SkDebugf("------- bad verb %d\n", verb);
             return false;
         }
         if (SkPipeVerb::kRestore == verb) {
@@ skipping 34 matching lines @@
 
 bool SkPipeDeserializer::playback(const void* data, size_t size, SkCanvas* canvas) {
     SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
                             &fImpl->fTypefaces, &fImpl->fFactories,
                             fImpl->fTFDeserializer);
     SkPipeReader reader(this, data, size);
     reader.setInflator(&inflator);
     return do_playback(reader, canvas);
 }