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 114 matching lines @@
     }
 
     void addBitmap(int index) {
         SkBitmap* bm;
         if(fBitmaps.count() == index) {
             bm = SkNEW(SkBitmap);
             *fBitmaps.append() = bm;
         } else {
             bm = fBitmaps[index];
         }
-        bm->unflatten(*fReader);
+        // When adding bitmaps, never use the bitmap storage. Bitmaps will always
+        // be either unflattened or decoded. Since bitmap storage takes priority in
+        // readBitmap, remove the bitmap storage and set it back afterwards.
+        SkBitmapHeapReader* storage = fReader->getBitmapStorage();
+        // The storage must be either this or the fSharedHeap, depending on fFlags.
+        SkASSERT((shouldFlattenBitmaps(fFlags) && this == storage)
+                 || (!shouldFlattenBitmaps(fFlags) && fSharedHeap == storage && storage != NULL));
+        fReader->setBitmapStorage(NULL);
+        fReader->readBitmap(bm);
+        fReader->setBitmapStorage(storage);
     }
 
     /**
      * Override of SkBitmapHeapReader, so that SkOrderedReadBuffer can use
      * these SkBitmaps for bitmap shaders.
      */
     virtual SkBitmap* getBitmap(int32_t index) const SK_OVERRIDE {
         return fBitmaps[index];
     }
 
@@ skipping 619 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;
 }