Refactor read and write buffers.

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"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkGPipe.h"
 #include "SkGPipePriv.h"
 #include "SkReader32.h"
 #include "SkStream.h"
 
 #include "SkAnnotation.h"
 #include "SkColorFilter.h"
 #include "SkDrawLooper.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkTypeface.h"
 #include "SkXfermode.h"
 
 static SkFlattenable::Type paintflat_to_flattype(PaintFlats pf) {
     static const uint8_t gEffectTypesInPaintFlatsOrder[] = {
         SkFlattenable::kSkColorFilter_Type,
@@ skipping 64 matching lines @@
         if (fFlags != flags) {
             fFlags = flags;
             this->updateReader();
         }
     }
 
     unsigned getFlags() const {
         return fFlags;
     }
 
-    void setReader(SkOrderedReadBuffer* reader) {
+    void setReader(SkReadBuffer* reader) {
         fReader = reader;
         this->updateReader();
     }
 
     const SkPaint& paint() const { return fPaint; }
     SkPaint* editPaint() { return &fPaint; }
 
     SkFlattenable* getFlat(unsigned index) const {
         if (0 == index) {
             return NULL;
@@ skipping 30 matching lines @@
         if(fBitmaps.count() == index) {
             bm = SkNEW(SkBitmap);
             *fBitmaps.append() = bm;
         } else {
             bm = fBitmaps[index];
         }
         fReader->readBitmap(bm);
     }
 
     /**
-     * Override of SkBitmapHeapReader, so that SkOrderedReadBuffer can use
+     * Override of SkBitmapHeapReader, so that SkReadBuffer can use
      * 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.
@@ skipping 26 matching lines @@
         paint->setTypeface(id ? fTypefaces[id - 1] : NULL);
     }
 
 private:
     void updateReader() {
         if (NULL == fReader) {
             return;
         }
         bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag);
         fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess,
-                                         SkFlattenableReadBuffer::kCrossProcess_Flag));
+                                         SkReadBuffer::kCrossProcess_Flag));
         if (crossProcess) {
             fReader->setFactoryArray(&fFactoryArray);
         } else {
             fReader->setFactoryArray(NULL);
         }
 
         if (shouldFlattenBitmaps(fFlags)) {
             fReader->setBitmapStorage(this);
         } else {
             fReader->setBitmapStorage(fSharedHeap);
         }
     }
-    SkOrderedReadBuffer*      fReader;
+    SkReadBuffer*      fReader;

[scroggo, 2014/01/29 20:07:21]

nit: fReader no longer lines up with other members.

[mtklein, 2014/01/29 20:38:29]

Done.

     SkPaint                   fPaint;
     SkTDArray<SkFlattenable*> fFlatArray;
     SkTDArray<SkTypeface*>    fTypefaces;
     SkTDArray<SkFlattenable::Factory> fFactoryArray;
     SkTDArray<SkBitmap*>      fBitmaps;
     bool                      fSilent;
     // Only used when sharing bitmaps with the writer.
     SkBitmapHeap*             fSharedHeap;
     unsigned                  fFlags;
 };
@@ skipping 459 matching lines @@
     SkPaint* p = state->editPaint();
     p->setTypeface(static_cast<SkTypeface*>(reader->readPtr()));
 }
 
 static void annotation_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
                           SkGPipeState* state) {
     SkPaint* p = state->editPaint();
 
     const size_t size = DrawOp_unpackData(op32);
     if (size > 0) {
-        SkOrderedReadBuffer buffer(reader->skip(size), size);
+        SkReadBuffer buffer(reader->skip(size), size);
         p->setAnnotation(SkNEW_ARGS(SkAnnotation, (buffer)))->unref();
         SkASSERT(buffer.offset() == size);
     } else {
         p->setAnnotation(NULL);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void def_Typeface_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState* state) {
@@ skipping 140 matching lines @@
 
     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);
+    SkReadBuffer 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;)
 
@@ skipping 16 matching lines @@
                 status = kReadAtom_Status;
                 break;
             }
     }
 
     if (bytesRead) {
         *bytesRead = reader.offset();
     }
     return status;
 }