Fixes for piping bitmaps with encoded data.

src/pipe/SkGPipeRead.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBitmapHeap.h"
@@ skipping 106 matching lines @@
     }
 
     void defFactory(const char* name) {
         SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
         if (factory) {
             SkASSERT(fFactoryArray.find(factory) < 0);
             *fFactoryArray.append() = factory;
         }
     }
 
+    /**
+     * Add a bitmap to the array of bitmaps, or replace an existing one.
+     * This is only used when in cross process mode without a shared heap.
+     */
     void addBitmap(int index) {
+        SkASSERT(shouldFlattenBitmaps(fFlags));
         SkBitmap* bm;
         if(fBitmaps.count() == index) {
             bm = SkNEW(SkBitmap);
             *fBitmaps.append() = bm;
         } else {
             bm = fBitmaps[index];
         }
-        bm->unflatten(*fReader);
+        fReader->readBitmap(bm);
     }
 
     /**
      * Override of SkBitmapHeapReader, so that SkOrderedReadBuffer can use
-     * these SkBitmaps for bitmap shaders.
+     * these SkBitmaps for bitmap shaders. Used only in cross process mode
+     * without a shared heap.
      */
     virtual SkBitmap* getBitmap(int32_t index) const SK_OVERRIDE {
+        SkASSERT(shouldFlattenBitmaps(fFlags));
         return fBitmaps[index];
     }
 
     /**
      * Needed to be a non-abstract subclass of SkBitmapHeapReader.
      */
     virtual void releaseRef(int32_t) SK_OVERRIDE {}
 
     void setSharedHeap(SkBitmapHeap* heap) {
         SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
         SkRefCnt_SafeAssign(fSharedHeap, heap);
         this->updateReader();
     }
 
+    /**
+     * Access the shared heap. Only used in the case when bitmaps are not
+     * flattened.
+     */
     SkBitmapHeap* getSharedHeap() const {
+        SkASSERT(!shouldFlattenBitmaps(fFlags));
         return fSharedHeap;
     }
 
     void addTypeface() {
         size_t size = fReader->read32();
         const void* data = fReader->skip(SkAlign4(size));
         SkMemoryStream stream(data, size, false);
         *fTypefaces.append() = SkTypeface::Deserialize(&stream);
     }
 
@@ skipping 597 matching lines @@
     SkSafeUnref(fSharedHeap);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGPipe.h"
 
 SkGPipeReader::SkGPipeReader() {
     fCanvas = NULL;
     fState = NULL;
+    fProc = NULL;
 }
 
 SkGPipeReader::SkGPipeReader(SkCanvas* target) {
     fCanvas = NULL;
     this->setCanvas(target);
     fState = NULL;
+    fProc = NULL;
 }
 
 void SkGPipeReader::setCanvas(SkCanvas *target) {
     SkRefCnt_SafeAssign(fCanvas, target);
 }
 
 SkGPipeReader::~SkGPipeReader() {
     SkSafeUnref(fCanvas);
     delete fState;
 }
 
 SkGPipeReader::Status SkGPipeReader::playback(const void* data, size_t length,
                                               uint32_t playbackFlags, size_t* bytesRead) {
     if (NULL == fCanvas) {
         return kError_Status;
     }
 
     if (NULL == fState) {
         fState = new SkGPipeState;
     }
 
     fState->setSilent(playbackFlags & kSilent_PlaybackFlag);
 
     SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1));
 
     const ReadProc* table = gReadTable;
     SkOrderedReadBuffer reader(data, length);
+    reader.setBitmapDecoder(fProc);
     SkCanvas* canvas = fCanvas;
     Status status = kEOF_Status;
 
     fState->setReader(&reader);
     while (!reader.eof()) {
         uint32_t op32 = reader.readUInt();
         unsigned op = DrawOp_unpackOp(op32);
         // SkDEBUGCODE(DrawOps drawOp = (DrawOps)op;)
 
         if (op >= SK_ARRAY_COUNT(gReadTable)) {
@@ skipping 15 matching lines @@
                 status = kReadAtom_Status;
                 break;
             }
     }
 
     if (bytesRead) {
         *bytesRead = reader.offset();
     }
     return status;
 }