Rename SkPicturePlayback to SkPictureData

src/core/SkPictureData.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 <new>
 #include "SkBBoxHierarchy.h"
 #include "SkDrawPictureCallback.h"
-#include "SkPicturePlayback.h"
+#include "SkPictureData.h"
 #include "SkPictureRecord.h"
 #include "SkPictureStateTree.h"
 #include "SkReadBuffer.h"
 #include "SkTypeface.h"
 #include "SkTSort.h"
 #include "SkWriteBuffer.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
 template <typename T> int SafeCount(const T* obj) {
     return obj ? obj->count() : 0;
 }
 
 /*  Define this to spew out a debug statement whenever we skip the remainder of
     a save/restore block because a clip... command returned false (empty).
  */
 #define SPEW_CLIP_SKIPPINGx
 
-SkPicturePlayback::PlaybackReplacements::ReplacementInfo*
-SkPicturePlayback::PlaybackReplacements::push() {
+SkPictureData::PlaybackReplacements::ReplacementInfo*
+SkPictureData::PlaybackReplacements::push() {
     SkDEBUGCODE(this->validate());
     return fReplacements.push();
 }
 
-void SkPicturePlayback::PlaybackReplacements::freeAll() {
+void SkPictureData::PlaybackReplacements::freeAll() {
     for (int i = 0; i < fReplacements.count(); ++i) {
         SkDELETE(fReplacements[i].fBM);
     }
     fReplacements.reset();
 }
 
 #ifdef SK_DEBUG
-void SkPicturePlayback::PlaybackReplacements::validate() const {
+void SkPictureData::PlaybackReplacements::validate() const {
     // Check that the ranges are monotonically increasing and non-overlapping
     if (fReplacements.count() > 0) {
         SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);
 
         for (int i = 1; i < fReplacements.count(); ++i) {
             SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
             SkASSERT(fReplacements[i-1].fStop < fReplacements[i].fStart);
         }
     }
 }
 #endif
 
-SkPicturePlayback::SkPicturePlayback(const SkPictInfo& info)
+SkPictureData::SkPictureData(const SkPictInfo& info)
     : fInfo(info) {
     this->init();
 }
 
-void SkPicturePlayback::initForPlayback() const {
+void SkPictureData::initForPlayback() const {
     // ensure that the paths bounds are pre-computed
     if (NULL != fPathHeap.get()) {
         for (int i = 0; i < fPathHeap->count(); i++) {
             (*fPathHeap.get())[i].updateBoundsCache();
         }
     }
 }
 
-SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record,
+SkPictureData::SkPictureData(const SkPictureRecord& record,
                                      const SkPictInfo& info,
                                      bool deepCopyOps)
     : fInfo(info) {
 #ifdef SK_DEBUG_SIZE
     size_t overallBytes, bitmapBytes, matricesBytes,
     paintBytes, pathBytes, pictureBytes, regionBytes;
     int bitmaps = record.bitmaps(&bitmapBytes);
     int matrices = record.matrices(&matricesBytes);
     int paints = record.paints(&paintBytes);
     int paths = record.paths(&pathBytes);
@@ skipping 79 matching lines @@
         SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths);
     if (pictures != 0)
         SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures);
     if (regions != 0)
         SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions);
     SkDebugf("\n");
 #endif
 }
 
 #ifdef SK_SUPPORT_LEGACY_PICTURE_CLONE
-SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInfo* deepCopyInfo)
+SkPictureData::SkPictureData(const SkPictureData& src, SkPictCopyInfo* deepCopyInfo)
     : fInfo(src.fInfo) {
     this->init();
 
     fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get()));
     fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
 
     fOpData = SkSafeRef(src.fOpData);
 
     fBoundingHierarchy = src.fBoundingHierarchy;
     fStateTree = src.fStateTree;
@@ skipping 35 matching lines @@
     for (int i = 0; i < fPictureCount; i++) {
         if (deepCopyInfo) {
             fPictureRefs[i] = src.fPictureRefs[i]->clone();
         } else {
             fPictureRefs[i] = src.fPictureRefs[i];
             fPictureRefs[i]->ref();
         }
     }
 }
 #else
-SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src) : fInfo(src.fInfo) {
+SkPictureData::SkPictureData(const SkPictureData& src) : fInfo(src.fInfo) {
     this->init();
 
     fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get()));
     fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
 
     fOpData = SkSafeRef(src.fOpData);
 
     fBoundingHierarchy = src.fBoundingHierarchy;
     fStateTree = src.fStateTree;
     fContentInfo.set(src.fContentInfo);
 
     SkSafeRef(fBoundingHierarchy);
     SkSafeRef(fStateTree);
 
     fBitmaps = SkSafeRef(src.fBitmaps);
     fPaints = SkSafeRef(src.fPaints);
 
     fPictureCount = src.fPictureCount;
     fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i] = SkRef(src.fPictureRefs[i]);
     }
 }
 #endif//SK_SUPPORT_LEGACY_PICTURE_CLONE
 
-void SkPicturePlayback::init() {
+void SkPictureData::init() {
     fBitmaps = NULL;
     fPaints = NULL;
     fPictureRefs = NULL;
     fPictureCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
     fBoundingHierarchy = NULL;
     fStateTree = NULL;
     fCachedActiveOps = NULL;
     fCurOffset = 0;
     fUseBBH = true;
     fStart = 0;
     fStop = 0;
     fReplacements = NULL;
 }
 
-SkPicturePlayback::~SkPicturePlayback() {
+SkPictureData::~SkPictureData() {
     SkSafeUnref(fOpData);
 
     SkSafeUnref(fBitmaps);
     SkSafeUnref(fPaints);
     SkSafeUnref(fBoundingHierarchy);
     SkSafeUnref(fStateTree);
 
     SkDELETE(fCachedActiveOps);
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     SkDELETE_ARRAY(fPictureRefs);
 
     SkDELETE(fFactoryPlayback);
 }
 
-void SkPicturePlayback::dumpSize() const {
+void SkPictureData::dumpSize() const {
     SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] paints=%d [%d]\n",
              fOpData->size(),
              SafeCount(fBitmaps), SafeCount(fBitmaps) * sizeof(SkBitmap),
              SafeCount(fPaints), SafeCount(fPaints) * sizeof(SkPaint));
     SkDebugf("--- picture size: paths=%d\n",
              SafeCount(fPathHeap.get()));
 }
 
-bool SkPicturePlayback::containsBitmaps() const {
+bool SkPictureData::containsBitmaps() const {
     if (fBitmaps && fBitmaps->count() > 0) {
         return true;
     }
     for (int i = 0; i < fPictureCount; ++i) {
         if (fPictureRefs[i]->willPlayBackBitmaps()) {
             return true;
         }
     }
     return false;
 }
@@ skipping 13 matching lines @@
         } else {
             size_t len = strlen(name);
             size += SkWStream::SizeOfPackedUInt(len);
             size += len;
         }
     }
 
     return size;
 }
 
-void SkPicturePlayback::WriteFactories(SkWStream* stream, const SkFactorySet& rec) {
+void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) {
     int count = rec.count();
 
     SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
     SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
     rec.copyToArray(array);
 
     size_t size = compute_chunk_size(array, count);
 
     // TODO: write_tag_size should really take a size_t
     SkPicture::WriteTagSize(stream, SK_PICT_FACTORY_TAG, (uint32_t) size);
     SkDEBUGCODE(size_t start = stream->bytesWritten());
     stream->write32(count);
 
     for (int i = 0; i < count; i++) {
         const char* name = SkFlattenable::FactoryToName(array[i]);
 //        SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name);
         if (NULL == name || 0 == *name) {
             stream->writePackedUInt(0);
         } else {
             size_t len = strlen(name);
             stream->writePackedUInt(len);
             stream->write(name, len);
         }
     }
 
     SkASSERT(size == (stream->bytesWritten() - start));
 }
 
-void SkPicturePlayback::WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec) {
+void SkPictureData::WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec) {
     int count = rec.count();
 
     SkPicture::WriteTagSize(stream, SK_PICT_TYPEFACE_TAG, count);
 
     SkAutoSTMalloc<16, SkTypeface*> storage(count);
     SkTypeface** array = (SkTypeface**)storage.get();
     rec.copyToArray((SkRefCnt**)array);
 
     for (int i = 0; i < count; i++) {
         array[i]->serialize(stream);
     }
 }
 
-void SkPicturePlayback::flattenToBuffer(SkWriteBuffer& buffer) const {
+void SkPictureData::flattenToBuffer(SkWriteBuffer& buffer) const {
     int i, n;
 
     if ((n = SafeCount(fBitmaps)) > 0) {
         SkPicture::WriteTagSize(buffer, SK_PICT_BITMAP_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writeBitmap((*fBitmaps)[i]);
         }
     }
 
     if ((n = SafeCount(fPaints)) > 0) {
         SkPicture::WriteTagSize(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writePaint((*fPaints)[i]);
         }
     }
 
     if ((n = SafeCount(fPathHeap.get())) > 0) {
         SkPicture::WriteTagSize(buffer, SK_PICT_PATH_BUFFER_TAG, n);
         fPathHeap->flatten(buffer);
     }
 }
 
-void SkPicturePlayback::serialize(SkWStream* stream,
+void SkPictureData::serialize(SkWStream* stream,
                                   SkPicture::EncodeBitmap encoder) const {
     SkPicture::WriteTagSize(stream, SK_PICT_READER_TAG, fOpData->size());
     stream->write(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
         SkPicture::WriteTagSize(stream, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i]->serialize(stream, encoder);
         }
     }
@@ skipping 17 matching lines @@
         WriteFactories(stream, factSet);
         WriteTypefaces(stream, typefaceSet);
 
         SkPicture::WriteTagSize(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
         buffer.writeToStream(stream);
     }
 
     stream->write32(SK_PICT_EOF_TAG);
 }
 
-void SkPicturePlayback::flatten(SkWriteBuffer& buffer) const {
+void SkPictureData::flatten(SkWriteBuffer& buffer) const {
     SkPicture::WriteTagSize(buffer, SK_PICT_READER_TAG, fOpData->size());
     buffer.writeByteArray(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
         SkPicture::WriteTagSize(buffer, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i]->flatten(buffer);
         }
     }
 
@@ skipping 20 matching lines @@
 
     uint32_t rbMask = 0;
     for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) {
         if (pictInfoFlags & gSD[i].fSrc) {
             rbMask |= gSD[i].fDst;
         }
     }
     return rbMask;
 }
 
-bool SkPicturePlayback::parseStreamTag(SkStream* stream,
+bool SkPictureData::parseStreamTag(SkStream* stream,
                                        uint32_t tag,
                                        uint32_t size,
                                        SkPicture::InstallPixelRefProc proc) {
     /*
      *  By the time we encounter BUFFER_SIZE_TAG, we need to have already seen
      *  its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
      *  but if they are present, they need to have been seen before the buffer.
      *
      *  We assert that if/when we see either of these, that we have not yet seen
      *  the buffer tag, because if we have, then its too-late to deal with the
@@ skipping 91 matching lines @@
                 if (!this->parseBufferTag(buffer, tag, size)) {
                     return false;
                 }
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
-bool SkPicturePlayback::parseBufferTag(SkReadBuffer& buffer,
+bool SkPictureData::parseBufferTag(SkReadBuffer& buffer,
                                        uint32_t tag, uint32_t size) {
     switch (tag) {
         case SK_PICT_BITMAP_BUFFER_TAG: {
             const int count = SkToInt(size);
             fBitmaps = SkTRefArray<SkBitmap>::Create(size);
             for (int i = 0; i < count; ++i) {
                 SkBitmap* bm = &fBitmaps->writableAt(i);
                 buffer.readBitmap(bm);
                 bm->setImmutable();
             }
@@ skipping 45 matching lines @@
                 return false;
             }
         } break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
-SkPicturePlayback* SkPicturePlayback::CreateFromStream(SkStream* stream,
-                                                       const SkPictInfo& info,
-                                                       SkPicture::InstallPixelRefProc proc) {
-    SkAutoTDelete<SkPicturePlayback> playback(SkNEW_ARGS(SkPicturePlayback, (info)));
+SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
+                                               const SkPictInfo& info,
+                                               SkPicture::InstallPixelRefProc proc) {
+    SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
 
-    if (!playback->parseStream(stream, proc)) {
+    if (!data->parseStream(stream, proc)) {
         return NULL;
     }
-    return playback.detach();
+    return data.detach();
 }
 
-SkPicturePlayback* SkPicturePlayback::CreateFromBuffer(SkReadBuffer& buffer,
-                                                       const SkPictInfo& info) {
-    SkAutoTDelete<SkPicturePlayback> playback(SkNEW_ARGS(SkPicturePlayback, (info)));
+SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
+                                               const SkPictInfo& info) {
+    SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
     buffer.setVersion(info.fVersion);
 
-    if (!playback->parseBuffer(buffer)) {
+    if (!data->parseBuffer(buffer)) {
         return NULL;
     }
-    return playback.detach();
+    return data.detach();
 }
 
-bool SkPicturePlayback::parseStream(SkStream* stream,
-                                    SkPicture::InstallPixelRefProc proc) {
+bool SkPictureData::parseStream(SkStream* stream,
+                                SkPicture::InstallPixelRefProc proc) {
     for (;;) {
         uint32_t tag = stream->readU32();
         if (SK_PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = stream->readU32();
         if (!this->parseStreamTag(stream, tag, size, proc)) {
             return false; // we're invalid
         }
     }
     return true;
 }
 
-bool SkPicturePlayback::parseBuffer(SkReadBuffer& buffer) {
+bool SkPictureData::parseBuffer(SkReadBuffer& buffer) {
     for (;;) {
         uint32_t tag = buffer.readUInt();
         if (SK_PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = buffer.readUInt();
         if (!this->parseBufferTag(buffer, tag, size)) {
             return false; // we're invalid
         }
@@ skipping 15 matching lines @@
     }
 
     void recordSkip(size_t bytes) {
         fCount += 1;
         fSize += bytes;
     }
 };
 #endif
 
 #ifdef SK_DEVELOPER
-bool SkPicturePlayback::preDraw(int opIndex, int type) {
+bool SkPictureData::preDraw(int opIndex, int type) {
     return false;
 }
 
-void SkPicturePlayback::postDraw(int opIndex) {
+void SkPictureData::postDraw(int opIndex) {
 }
 #endif
 
 /*
  * Read the next op code and chunk size from 'reader'. The returned size
  * is the entire size of the chunk (including the opcode). Thus, the
  * offset just prior to calling read_op_and_size + 'size' is the offset
  * to the next chunk's op code. This also means that the size of a chunk
  * with no arguments (just an opcode) will be 4.
  */
 static DrawType read_op_and_size(SkReader32* reader, uint32_t* size) {
     uint32_t temp = reader->readInt();
     uint32_t op;
     if (((uint8_t) temp) == temp) {
         // old skp file - no size information
         op = temp;
         *size = 0;
     } else {
         UNPACK_8_24(temp, op, *size);
         if (MASK_24 == *size) {
             *size = reader->readInt();
         }
     }
     return (DrawType) op;
 }
 
-uint32_t SkPicturePlayback::CachedOperationList::offset(int index) const {
+uint32_t SkPictureData::CachedOperationList::offset(int index) const {
     SkASSERT(index < fOps.count());
     return ((SkPictureStateTree::Draw*)fOps[index])->fOffset;
 }
 
-const SkMatrix& SkPicturePlayback::CachedOperationList::matrix(int index) const {
+const SkMatrix& SkPictureData::CachedOperationList::matrix(int index) const {
     SkASSERT(index < fOps.count());
     return *((SkPictureStateTree::Draw*)fOps[index])->fMatrix;
 }
 
-const SkPicture::OperationList& SkPicturePlayback::getActiveOps(const SkIRect& query) {
+const SkPicture::OperationList& SkPictureData::getActiveOps(const SkIRect& query) {
     if (NULL == fStateTree || NULL == fBoundingHierarchy) {
         return SkPicture::OperationList::InvalidList();
     }
 
     if (NULL == fCachedActiveOps) {
         fCachedActiveOps = SkNEW(CachedOperationList);
     }
 
     if (query == fCachedActiveOps->fCacheQueryRect) {
         return *fCachedActiveOps;
     }
 
     fCachedActiveOps->fOps.rewind();
 
     fBoundingHierarchy->search(query, &(fCachedActiveOps->fOps));
     if (0 != fCachedActiveOps->fOps.count()) {
         SkTQSort<SkPictureStateTree::Draw>(
             reinterpret_cast<SkPictureStateTree::Draw**>(fCachedActiveOps->fOps.begin()),
             reinterpret_cast<SkPictureStateTree::Draw**>(fCachedActiveOps->fOps.end()-1));
     }
 
     fCachedActiveOps->fCacheQueryRect = query;
     return *fCachedActiveOps;
 }
 
 class SkAutoResetOpID {
 public:
-    SkAutoResetOpID(SkPicturePlayback* playback) : fPlayback(playback) { }
+    SkAutoResetOpID(SkPictureData* data) : fData(data) { }
     ~SkAutoResetOpID() {
-        if (NULL != fPlayback) {
-            fPlayback->resetOpID();
+        if (NULL != fData) {
+            fData->resetOpID();
         }
     }
 
 private:
-    SkPicturePlayback* fPlayback;
+    SkPictureData* fData;
 };
 
 // TODO: Replace with hash or pass in "lastLookedUp" hint
-SkPicturePlayback::PlaybackReplacements::ReplacementInfo*
-SkPicturePlayback::PlaybackReplacements::lookupByStart(size_t start) {
+SkPictureData::PlaybackReplacements::ReplacementInfo*
+SkPictureData::PlaybackReplacements::lookupByStart(size_t start) {
     SkDEBUGCODE(this->validate());
     for (int i = 0; i < fReplacements.count(); ++i) {
         if (start == fReplacements[i].fStart) {
             return &fReplacements[i];
         } else if (start < fReplacements[i].fStart) {
             return NULL;  // the ranges are monotonically increasing and non-overlapping
         }
     }
 
     return NULL;
 }
 
-void SkPicturePlayback::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) {
+void SkPictureData::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) {
     SkAutoResetOpID aroi(this);
     SkASSERT(0 == fCurOffset);
 
 #ifdef ENABLE_TIME_DRAW
     SkAutoTime  at("SkPicture::draw", 50);
 #endif
 
 #ifdef SPEW_CLIP_SKIPPING
     SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull;
     int opCount = 0;
@@ skipping 80 matching lines @@
             if (offset >= fStop) {
                 uint32_t size;
                 SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
                 SkASSERT(RESTORE == op);
                 return;
             }
         }
 
         if (NULL != fReplacements) {
             // Potentially replace a block of operations with a single drawBitmap call
-            SkPicturePlayback::PlaybackReplacements::ReplacementInfo* temp =
+            SkPictureData::PlaybackReplacements::ReplacementInfo* temp =
                                             fReplacements->lookupByStart(reader.offset());
             if (NULL != temp) {
                 SkASSERT(NULL != temp->fBM);
                 SkASSERT(NULL != temp->fPaint);
                 canvas.save();
                 canvas.setMatrix(initialMatrix);
                 SkRect src = SkRect::Make(temp->fSrcRect);
                 SkRect dst = SkRect::MakeXYWH(temp->fPos.fX, temp->fPos.fY,
                                               temp->fSrcRect.width(),
                                               temp->fSrcRect.height());
@@ skipping 433 matching lines @@
              size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount,
                  skipPath.fCount, skipRegion.fCount, skipCull.fCount);
         SkDebugf("--- Total ops: %d\n", opCount);
     }
 #endif
 //    this->dumpSize();
 }
 
 
 #if SK_SUPPORT_GPU
-bool SkPicturePlayback::suitableForGpuRasterization(GrContext* context, const char **reason,
+bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
                                                     int sampleCount) const {
     // TODO: the heuristic used here needs to be refined
     static const int kNumPaintWithPathEffectUsesTol = 1;
     static const int kNumAAConcavePaths = 5;
 
     SkASSERT(fContentInfo.numAAHairlineConcavePaths() <= fContentInfo.numAAConcavePaths());
 
     int numNonDashedPathEffects = fContentInfo.numPaintWithPathEffectUses() -
                                   fContentInfo.numFastPathDashEffects();
 
@@ skipping 13 matching lines @@
             }
         } else if ((fContentInfo.numAAConcavePaths() - fContentInfo.numAAHairlineConcavePaths())
                     >= kNumAAConcavePaths)
             *reason = "Too many anti-aliased concave paths.";
         else
             *reason = "Unknown reason for GPU unsuitability.";
     }
     return ret;
 }
 
-bool SkPicturePlayback::suitableForGpuRasterization(GrContext* context, const char **reason,
-                                                    GrPixelConfig config, SkScalar dpi) const {
+bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
+                                                GrPixelConfig config, SkScalar dpi) const {
 
     if (context != NULL) {
         return this->suitableForGpuRasterization(context, reason,
                                                  context->getRecommendedSampleCount(config, dpi));
     } else {
         return this->suitableForGpuRasterization(NULL, reason);
     }
 }
 
 #endif
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG_SIZE
-int SkPicturePlayback::size(size_t* sizePtr) {
+int SkPictureData::size(size_t* sizePtr) {
     int objects = bitmaps(sizePtr);
     objects += paints(sizePtr);
     objects += paths(sizePtr);
     objects += pictures(sizePtr);
     objects += regions(sizePtr);
     *sizePtr = fOpData.size();
     return objects;
 }
 
-int SkPicturePlayback::bitmaps(size_t* size) {
+int SkPictureData::bitmaps(size_t* size) {
     size_t result = 0;
     for (int index = 0; index < fBitmapCount; index++) {
      //   const SkBitmap& bitmap = fBitmaps[index];
         result += sizeof(SkBitmap); // bitmap->size();
     }
     *size = result;
     return fBitmapCount;
 }
 
-int SkPicturePlayback::paints(size_t* size) {
+int SkPictureData::paints(size_t* size) {
     size_t result = 0;
     for (int index = 0; index < fPaintCount; index++) {
     //    const SkPaint& paint = fPaints[index];
         result += sizeof(SkPaint); // paint->size();
     }
     *size = result;
     return fPaintCount;
 }
 
-int SkPicturePlayback::paths(size_t* size) {
+int SkPictureData::paths(size_t* size) {
     size_t result = 0;
     for (int index = 0; index < fPathCount; index++) {
         const SkPath& path = fPaths[index];
         result += path.flatten(NULL);
     }
     *size = result;
     return fPathCount;
 }
 #endif
 
 #ifdef SK_DEBUG_DUMP
-void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const {
+void SkPictureData::dumpBitmap(const SkBitmap& bitmap) const {
     char pBuffer[DUMP_BUFFER_SIZE];
     char* bufferPtr = pBuffer;
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "BitmapData bitmap%p = {", &bitmap);
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "{kWidth, %d}, ", bitmap.width());
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "{kHeight, %d}, ", bitmap.height());
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "{kRowBytes, %d}, ", bitmap.rowBytes());
@@ skipping 136 matching lines @@
     int textEncoding = paint.getTextEncoding();
     if (textEncoding != defaultPaint.getTextEncoding())
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "{kTextEncoding, 0x%x}, ", textEncoding);
     SkDebugf("%s{0}};\n", pBuffer);
 
     SkDebugf("PaintData paint%p = {paintPtrs%p, paintScalars%p, paintInts%p};\n",
         &paint, &paint, &paint, &paint);
 }
 
-void SkPicturePlayback::dumpPath(const SkPath& path) const {
+void SkPictureData::dumpPath(const SkPath& path) const {
     SkDebugf("path dump unimplemented\n");
 }
 
-void SkPicturePlayback::dumpPicture(const SkPicture& picture) const {
+void SkPictureData::dumpPicture(const SkPicture& picture) const {
     SkDebugf("picture dump unimplemented\n");
 }
 
-void SkPicturePlayback::dumpRegion(const SkRegion& region) const {
+void SkPictureData::dumpRegion(const SkRegion& region) const {
     SkDebugf("region dump unimplemented\n");
 }
 
-int SkPicturePlayback::dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType) {
+int SkPictureData::dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType) {
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "k%s, ", DrawTypeToString(drawType));
 }
 
-int SkPicturePlayback::dumpInt(char* bufferPtr, char* buffer, char* name) {
+int SkPictureData::dumpInt(char* bufferPtr, char* buffer, char* name) {
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "%s:%d, ", name, getInt());
 }
 
-int SkPicturePlayback::dumpRect(char* bufferPtr, char* buffer, char* name) {
+int SkPictureData::dumpRect(char* bufferPtr, char* buffer, char* name) {
     const SkRect* rect = fReader.skipRect();
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft),
         SkScalarToFloat(rect.fTop),
         SkScalarToFloat(rect.fRight), SkScalarToFloat(rect.fBottom));
 }
 
-int SkPicturePlayback::dumpPoint(char* bufferPtr, char* buffer, char* name) {
+int SkPictureData::dumpPoint(char* bufferPtr, char* buffer, char* name) {
     SkPoint pt;
     getPoint(&pt);
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX),
         SkScalarToFloat(pt.fY));
 }
 
-void SkPicturePlayback::dumpPointArray(char** bufferPtrPtr, char* buffer, int count) {
+void SkPictureData::dumpPointArray(char** bufferPtrPtr, char* buffer, int count) {
     char* bufferPtr = *bufferPtrPtr;
     const SkPoint* pts = (const SkPoint*)fReadStream.getAtPos();
     fReadStream.skip(sizeof(SkPoint) * count);
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "count:%d {", count);
     for (int index = 0; index < count; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX),
         SkScalarToFloat(pts[index].fY));
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "} ");
     *bufferPtrPtr = bufferPtr;
 }
 
-int SkPicturePlayback::dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr) {
+int SkPictureData::dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr) {
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "%s:%p, ", name, ptr);
 }
 
-int SkPicturePlayback::dumpRectPtr(char* bufferPtr, char* buffer, char* name) {
+int SkPictureData::dumpRectPtr(char* bufferPtr, char* buffer, char* name) {
     char result;
     fReadStream.read(&result, sizeof(result));
     if (result)
         return dumpRect(bufferPtr, buffer, name);
     else
         return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
             "%s:NULL, ", name);
 }
 
-int SkPicturePlayback::dumpScalar(char* bufferPtr, char* buffer, char* name) {
+int SkPictureData::dumpScalar(char* bufferPtr, char* buffer, char* name) {
     return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
         "%s:%d, ", name, getScalar());
 }
 
-void SkPicturePlayback::dumpText(char** bufferPtrPtr, char* buffer) {
+void SkPictureData::dumpText(char** bufferPtrPtr, char* buffer) {
     char* bufferPtr = *bufferPtrPtr;
     int length = getInt();
     bufferPtr += dumpDrawType(bufferPtr, buffer);
     fReadStream.skipToAlign4();
     char* text = (char*) fReadStream.getAtPos();
     fReadStream.skip(length);
     bufferPtr += dumpInt(bufferPtr, buffer, "length");
     int limit = DUMP_BUFFER_SIZE - (bufferPtr - buffer) - 2;
     length >>= 1;
     if (limit > length)
@@ skipping 29 matching lines @@
 
 #define DUMP_PTR(name, ptr) \
     bufferPtr += dumpPtr(bufferPtr, buffer, #name, (void*) ptr)
 
 #define DUMP_SCALAR(name) \
     bufferPtr += dumpScalar(bufferPtr, buffer, #name)
 
 #define DUMP_TEXT() \
     dumpText(&bufferPtr, buffer)
 
-void SkPicturePlayback::dumpStream() {
+void SkPictureData::dumpStream() {
     SkDebugf("RecordStream stream = {\n");
     DrawType drawType;
     TextContainer text;
     fReadStream.rewind();
     char buffer[DUMP_BUFFER_SIZE], * bufferPtr;
     while (fReadStream.read(&drawType, sizeof(drawType))) {
         bufferPtr = buffer;
         DUMP_DRAWTYPE(drawType);
         switch (drawType) {
             case CLIP_PATH: {
@@ skipping 98 matching lines @@
                 DUMP_SCALAR(dx);
                 DUMP_SCALAR(dy);
                 } break;
             default:
                 SkASSERT(0);
         }
         SkDebugf("%s\n", buffer);
     }
 }
 
-void SkPicturePlayback::dump() const {
+void SkPictureData::dump() const {
     char pBuffer[DUMP_BUFFER_SIZE];
     char* bufferPtr = pBuffer;
     int index;
     if (fBitmapCount > 0)
         SkDebugf("// bitmaps (%d)\n", fBitmapCount);
     for (index = 0; index < fBitmapCount; index++) {
         const SkBitmap& bitmap = fBitmaps[index];
         dumpBitmap(bitmap);
     }
     if (fBitmapCount > 0)
@@ skipping 42 matching lines @@
     bufferPtr = pBuffer;
     if (fPictureCount > 0)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "Pictures pictures = {");
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
-    const_cast<SkPicturePlayback*>(this)->dumpStream();
+    const_cast<SkPictureData*>(this)->dumpStream();
 }
 
 #endif