src/third_party/skia/src/core/SkPictureData.cpp

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7 #include <new>
   8 #include "SkBBoxHierarchy.h"
   9 #include "SkDrawPictureCallback.h"
  10 #include "SkPictureData.h"
  11 #include "SkPictureRecord.h"
  12 #include "SkReadBuffer.h"
  13 #include "SkTextBlob.h"
  14 #include "SkTypeface.h"
  15 #include "SkTSort.h"
  16 #include "SkWriteBuffer.h"
  17
  18 #if SK_SUPPORT_GPU
  19 #include "GrContext.h"
  20 #endif
  21
  22 template <typename T> int SafeCount(const T* obj) {
  23     return obj ? obj->count() : 0;
  24 }
  25
  26 SkPictureData::SkPictureData(const SkPictInfo& info)
  27     : fInfo(info) {
  28     this->init();
  29 }
  30
  31 void SkPictureData::initForPlayback() const {
  32     // ensure that the paths bounds are pre-computed
  33     if (fPathHeap.get()) {
  34         for (int i = 0; i < fPathHeap->count(); i++) {
  35             (*fPathHeap.get())[i].updateBoundsCache();
  36         }
  37     }
  38 }
  39
  40 SkPictureData::SkPictureData(const SkPictureRecord& record,
  41                              const SkPictInfo& info,
  42                              bool deepCopyOps)
  43     : fInfo(info) {
  44
  45     this->init();
  46
  47     fOpData = record.opData(deepCopyOps);
  48
  49     fBoundingHierarchy = record.fBoundingHierarchy;
  50     fStateTree = record.fStateTree;
  51
  52     SkSafeRef(fBoundingHierarchy);
  53     SkSafeRef(fStateTree);
  54     fContentInfo.set(record.fContentInfo);
  55
  56     if (fBoundingHierarchy) {
  57         fBoundingHierarchy->flushDeferredInserts();
  58     }
  59
  60     // copy over the refcnt dictionary to our reader
  61     record.fFlattenableHeap.setupPlaybacks();
  62
  63     fBitmaps = record.fBitmapHeap->extractBitmaps();
  64     fPaints = record.fPaints.unflattenToArray();
  65
  66     fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap));
  67     fPathHeap.reset(SkSafeRef(record.pathHeap()));
  68
  69     this->initForPlayback();
  70
  71     const SkTDArray<const SkPicture* >& pictures = record.getPictureRefs();
  72     fPictureCount = pictures.count();
  73     if (fPictureCount > 0) {
  74         fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
  75         for (int i = 0; i < fPictureCount; i++) {
  76             fPictureRefs[i] = pictures[i];
  77             fPictureRefs[i]->ref();
  78         }
  79     }
  80
  81     // templatize to consolidate with similar picture logic?
  82     const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs();
  83     fTextBlobCount = blobs.count();
  84     if (fTextBlobCount > 0) {
  85         fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
  86         for (int i = 0; i < fTextBlobCount; ++i) {
  87             fTextBlobRefs[i] = SkRef(blobs[i]);
  88         }
  89     }
  90 }
  91
  92 #ifdef SK_SUPPORT_LEGACY_PICTURE_CLONE
  93 SkPictureData::SkPictureData(const SkPictureData& src, SkPictCopyInfo* deepCopyInfo)
  94     : fInfo(src.fInfo) {
  95     this->init();
  96
  97     fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get()));
  98     fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
  99
 100     fOpData = SkSafeRef(src.fOpData);
 101
 102     fBoundingHierarchy = src.fBoundingHierarchy;
 103     fStateTree = src.fStateTree;
 104     fContentInfo.set(src.fContentInfo);
 105
 106     SkSafeRef(fBoundingHierarchy);
 107     SkSafeRef(fStateTree);
 108
 109     if (deepCopyInfo) {
 110         int paintCount = SafeCount(src.fPaints);
 111
 112         if (src.fBitmaps) {
 113             fBitmaps = SkTRefArray<SkBitmap>::Create(src.fBitmaps->begin(), src.fBitmaps->count());
 114         }
 115
 116         fPaints = SkTRefArray<SkPaint>::Create(paintCount);
 117         SkASSERT(deepCopyInfo->paintData.count() == paintCount);
 118         SkBitmapHeap* bmHeap = deepCopyInfo->controller.getBitmapHeap();
 119         SkTypefacePlayback* tfPlayback = deepCopyInfo->controller.getTypefacePlayback();
 120         for (int i = 0; i < paintCount; i++) {
 121             if (deepCopyInfo->paintData[i]) {
 122                 deepCopyInfo->paintData[i]->unflatten<SkPaint::FlatteningTraits>(
 123                     &fPaints->writableAt(i), bmHeap, tfPlayback);
 124             } else {
 125                 // needs_deep_copy was false, so just need to assign
 126                 fPaints->writableAt(i) = src.fPaints->at(i);
 127             }
 128         }
 129
 130     } else {
 131         fBitmaps = SkSafeRef(src.fBitmaps);
 132         fPaints = SkSafeRef(src.fPaints);
 133     }
 134
 135     fPictureCount = src.fPictureCount;
 136     fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
 137     for (int i = 0; i < fPictureCount; i++) {
 138         if (deepCopyInfo) {
 139             fPictureRefs[i] = src.fPictureRefs[i]->clone();
 140         } else {
 141             fPictureRefs[i] = src.fPictureRefs[i];
 142             fPictureRefs[i]->ref();
 143         }
 144     }
 145 }
 146 #endif//SK_SUPPORT_LEGACY_PICTURE_CLONE
 147
 148 void SkPictureData::init() {
 149     fBitmaps = NULL;
 150     fPaints = NULL;
 151     fPictureRefs = NULL;
 152     fPictureCount = 0;
 153     fTextBlobRefs = NULL;
 154     fTextBlobCount = 0;
 155     fOpData = NULL;
 156     fFactoryPlayback = NULL;
 157     fBoundingHierarchy = NULL;
 158     fStateTree = NULL;
 159 }
 160
 161 SkPictureData::~SkPictureData() {
 162     SkSafeUnref(fOpData);
 163
 164     SkSafeUnref(fBitmaps);
 165     SkSafeUnref(fPaints);
 166     SkSafeUnref(fBoundingHierarchy);
 167     SkSafeUnref(fStateTree);
 168
 169     for (int i = 0; i < fPictureCount; i++) {
 170         fPictureRefs[i]->unref();
 171     }
 172     SkDELETE_ARRAY(fPictureRefs);
 173
 174     for (int i = 0; i < fTextBlobCount; i++) {
 175         fTextBlobRefs[i]->unref();
 176     }
 177     SkDELETE_ARRAY(fTextBlobRefs);
 178
 179     SkDELETE(fFactoryPlayback);
 180 }
 181
 182 bool SkPictureData::containsBitmaps() const {
 183     if (fBitmaps && fBitmaps->count() > 0) {
 184         return true;
 185     }
 186     for (int i = 0; i < fPictureCount; ++i) {
 187         if (fPictureRefs[i]->willPlayBackBitmaps()) {
 188             return true;
 189         }
 190     }
 191     return false;
 192 }
 193
 194 ///////////////////////////////////////////////////////////////////////////////
 195 ///////////////////////////////////////////////////////////////////////////////
 196
 197 #include "SkStream.h"
 198
 199 static size_t compute_chunk_size(SkFlattenable::Factory* array, int count) {
 200     size_t size = 4;  // for 'count'
 201
 202     for (int i = 0; i < count; i++) {
 203         const char* name = SkFlattenable::FactoryToName(array[i]);
 204         if (NULL == name || 0 == *name) {
 205             size += SkWStream::SizeOfPackedUInt(0);
 206         } else {
 207             size_t len = strlen(name);
 208             size += SkWStream::SizeOfPackedUInt(len);
 209             size += len;
 210         }
 211     }
 212
 213     return size;
 214 }
 215
 216 static void write_tag_size(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
 217     buffer.writeUInt(tag);
 218     buffer.writeUInt(SkToU32(size));
 219 }
 220
 221 static void write_tag_size(SkWStream* stream, uint32_t tag, size_t size) {
 222     stream->write32(tag);
 223     stream->write32(SkToU32(size));
 224 }
 225
 226 void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) {
 227     int count = rec.count();
 228
 229     SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
 230     SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
 231     rec.copyToArray(array);
 232
 233     size_t size = compute_chunk_size(array, count);
 234
 235     // TODO: write_tag_size should really take a size_t
 236     write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size);
 237     SkDEBUGCODE(size_t start = stream->bytesWritten());
 238     stream->write32(count);
 239
 240     for (int i = 0; i < count; i++) {
 241         const char* name = SkFlattenable::FactoryToName(array[i]);
 242         if (NULL == name || 0 == *name) {
 243             stream->writePackedUInt(0);
 244         } else {
 245             size_t len = strlen(name);
 246             stream->writePackedUInt(len);
 247             stream->write(name, len);
 248         }
 249     }
 250
 251     SkASSERT(size == (stream->bytesWritten() - start));
 252 }
 253
 254 void SkPictureData::WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec) {
 255     int count = rec.count();
 256
 257     write_tag_size(stream, SK_PICT_TYPEFACE_TAG, count);
 258
 259     SkAutoSTMalloc<16, SkTypeface*> storage(count);
 260     SkTypeface** array = (SkTypeface**)storage.get();
 261     rec.copyToArray((SkRefCnt**)array);
 262
 263     for (int i = 0; i < count; i++) {
 264         array[i]->serialize(stream);
 265     }
 266 }
 267
 268 void SkPictureData::flattenToBuffer(SkWriteBuffer& buffer) const {
 269     int i, n;
 270
 271     if ((n = SafeCount(fBitmaps)) > 0) {
 272         write_tag_size(buffer, SK_PICT_BITMAP_BUFFER_TAG, n);
 273         for (i = 0; i < n; i++) {
 274             buffer.writeBitmap((*fBitmaps)[i]);
 275         }
 276     }
 277
 278     if ((n = SafeCount(fPaints)) > 0) {
 279         write_tag_size(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
 280         for (i = 0; i < n; i++) {
 281             buffer.writePaint((*fPaints)[i]);
 282         }
 283     }
 284
 285     if ((n = SafeCount(fPathHeap.get())) > 0) {
 286         write_tag_size(buffer, SK_PICT_PATH_BUFFER_TAG, n);
 287         fPathHeap->flatten(buffer);
 288     }
 289
 290     if (fTextBlobCount > 0) {
 291         write_tag_size(buffer, SK_PICT_TEXTBLOB_BUFFER_TAG, fTextBlobCount);
 292         for (i = 0; i  < fTextBlobCount; ++i) {
 293             fTextBlobRefs[i]->flatten(buffer);
 294         }
 295     }
 296 }
 297
 298 void SkPictureData::serialize(SkWStream* stream,
 299                                   SkPicture::EncodeBitmap encoder) const {
 300     write_tag_size(stream, SK_PICT_READER_TAG, fOpData->size());
 301     stream->write(fOpData->bytes(), fOpData->size());
 302
 303     if (fPictureCount > 0) {
 304         write_tag_size(stream, SK_PICT_PICTURE_TAG, fPictureCount);
 305         for (int i = 0; i < fPictureCount; i++) {
 306             fPictureRefs[i]->serialize(stream, encoder);
 307         }
 308     }
 309
 310     // Write some of our data into a writebuffer, and then serialize that
 311     // into our stream
 312     {
 313         SkRefCntSet  typefaceSet;
 314         SkFactorySet factSet;
 315
 316         SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag);
 317         buffer.setTypefaceRecorder(&typefaceSet);
 318         buffer.setFactoryRecorder(&factSet);
 319         buffer.setBitmapEncoder(encoder);
 320
 321         this->flattenToBuffer(buffer);
 322
 323         // We have to write these two sets into the stream *before* we write
 324         // the buffer, since parsing that buffer will require that we already
 325         // have these sets available to use.
 326         WriteFactories(stream, factSet);
 327         WriteTypefaces(stream, typefaceSet);
 328
 329         write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
 330         buffer.writeToStream(stream);
 331     }
 332
 333     stream->write32(SK_PICT_EOF_TAG);
 334 }
 335
 336 void SkPictureData::flatten(SkWriteBuffer& buffer) const {
 337     write_tag_size(buffer, SK_PICT_READER_TAG, fOpData->size());
 338     buffer.writeByteArray(fOpData->bytes(), fOpData->size());
 339
 340     if (fPictureCount > 0) {
 341         write_tag_size(buffer, SK_PICT_PICTURE_TAG, fPictureCount);
 342         for (int i = 0; i < fPictureCount; i++) {
 343             fPictureRefs[i]->flatten(buffer);
 344         }
 345     }
 346
 347     // Write this picture playback's data into a writebuffer
 348     this->flattenToBuffer(buffer);
 349     buffer.write32(SK_PICT_EOF_TAG);
 350 }
 351
 352 ///////////////////////////////////////////////////////////////////////////////
 353
 354 /**
 355  *  Return the corresponding SkReadBuffer flags, given a set of
 356  *  SkPictInfo flags.
 357  */
 358 static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) {
 359     static const struct {
 360         uint32_t    fSrc;
 361         uint32_t    fDst;
 362     } gSD[] = {
 363         { SkPictInfo::kCrossProcess_Flag,   SkReadBuffer::kCrossProcess_Flag },
 364         { SkPictInfo::kScalarIsFloat_Flag,  SkReadBuffer::kScalarIsFloat_Flag },
 365         { SkPictInfo::kPtrIs64Bit_Flag,     SkReadBuffer::kPtrIs64Bit_Flag },
 366     };
 367
 368     uint32_t rbMask = 0;
 369     for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) {
 370         if (pictInfoFlags & gSD[i].fSrc) {
 371             rbMask |= gSD[i].fDst;
 372         }
 373     }
 374     return rbMask;
 375 }
 376
 377 bool SkPictureData::parseStreamTag(SkStream* stream,
 378                                    uint32_t tag,
 379                                    uint32_t size,
 380                                    SkPicture::InstallPixelRefProc proc) {
 381     /*
 382      *  By the time we encounter BUFFER_SIZE_TAG, we need to have already seen
 383      *  its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
 384      *  but if they are present, they need to have been seen before the buffer.
 385      *
 386      *  We assert that if/when we see either of these, that we have not yet seen
 387      *  the buffer tag, because if we have, then its too-late to deal with the
 388      *  factories or typefaces.
 389      */
 390     SkDEBUGCODE(bool haveBuffer = false;)
 391
 392     switch (tag) {
 393         case SK_PICT_READER_TAG:
 394             SkASSERT(NULL == fOpData);
 395             fOpData = SkData::NewFromStream(stream, size);
 396             if (!fOpData) {
 397                 return false;
 398             }
 399             break;
 400         case SK_PICT_FACTORY_TAG: {
 401             SkASSERT(!haveBuffer);
 402         // Remove this code when v21 and below are no longer supported. At the
 403         // same time add a new 'count' variable and use it rather then reusing 'size'.
 404 #ifndef DISABLE_V21_COMPATIBILITY_CODE
 405             if (fInfo.fVersion >= 22) {
 406                 // in v22 this tag's size represents the size of the chunk in bytes
 407                 // and the number of factory strings is written out separately
 408 #endif
 409                 size = stream->readU32();
 410 #ifndef DISABLE_V21_COMPATIBILITY_CODE
 411             }
 412 #endif
 413             fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (size));
 414             for (size_t i = 0; i < size; i++) {
 415                 SkString str;
 416                 const size_t len = stream->readPackedUInt();
 417                 str.resize(len);
 418                 if (stream->read(str.writable_str(), len) != len) {
 419                     return false;
 420                 }
 421                 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
 422             }
 423         } break;
 424         case SK_PICT_TYPEFACE_TAG: {
 425             SkASSERT(!haveBuffer);
 426             const int count = SkToInt(size);
 427             fTFPlayback.setCount(count);
 428             for (int i = 0; i < count; i++) {
 429                 SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream));
 430                 if (!tf.get()) {    // failed to deserialize
 431                     // fTFPlayback asserts it never has a null, so we plop in
 432                     // the default here.
 433                     tf.reset(SkTypeface::RefDefault());
 434                 }
 435                 fTFPlayback.set(i, tf);
 436             }
 437         } break;
 438         case SK_PICT_PICTURE_TAG: {
 439             fPictureCount = size;
 440             fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
 441             bool success = true;
 442             int i = 0;
 443             for ( ; i < fPictureCount; i++) {
 444                 fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc);
 445                 if (NULL == fPictureRefs[i]) {
 446                     success = false;
 447                     break;
 448                 }
 449             }
 450             if (!success) {
 451                 // Delete all of the pictures that were already created (up to but excluding i):
 452                 for (int j = 0; j < i; j++) {
 453                     fPictureRefs[j]->unref();
 454                 }
 455                 // Delete the array
 456                 SkDELETE_ARRAY(fPictureRefs);
 457                 fPictureCount = 0;
 458                 return false;
 459             }
 460         } break;
 461         case SK_PICT_BUFFER_SIZE_TAG: {
 462             SkAutoMalloc storage(size);
 463             if (stream->read(storage.get(), size) != size) {
 464                 return false;
 465             }
 466
 467             SkReadBuffer buffer(storage.get(), size);
 468             buffer.setFlags(pictInfoFlagsToReadBufferFlags(fInfo.fFlags));
 469             buffer.setVersion(fInfo.fVersion);
 470
 471             fFactoryPlayback->setupBuffer(buffer);
 472             fTFPlayback.setupBuffer(buffer);
 473             buffer.setBitmapDecoder(proc);
 474
 475             while (!buffer.eof()) {
 476                 tag = buffer.readUInt();
 477                 size = buffer.readUInt();
 478                 if (!this->parseBufferTag(buffer, tag, size)) {
 479                     return false;
 480                 }
 481             }
 482             SkDEBUGCODE(haveBuffer = true;)
 483         } break;
 484     }
 485     return true;    // success
 486 }
 487
 488 bool SkPictureData::parseBufferTag(SkReadBuffer& buffer,
 489                                    uint32_t tag, uint32_t size) {
 490     switch (tag) {
 491         case SK_PICT_BITMAP_BUFFER_TAG: {
 492             const int count = SkToInt(size);
 493             fBitmaps = SkTRefArray<SkBitmap>::Create(size);
 494             for (int i = 0; i < count; ++i) {
 495                 SkBitmap* bm = &fBitmaps->writableAt(i);
 496                 buffer.readBitmap(bm);
 497                 bm->setImmutable();
 498             }
 499         } break;
 500         case SK_PICT_PAINT_BUFFER_TAG: {
 501             const int count = SkToInt(size);
 502             fPaints = SkTRefArray<SkPaint>::Create(size);
 503             for (int i = 0; i < count; ++i) {
 504                 buffer.readPaint(&fPaints->writableAt(i));
 505             }
 506         } break;
 507         case SK_PICT_PATH_BUFFER_TAG:
 508             if (size > 0) {
 509                 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
 510             }
 511             break;
 512         case SK_PICT_TEXTBLOB_BUFFER_TAG: {
 513             if (!buffer.validate((0 == fTextBlobCount) && (NULL == fTextBlobRefs))) {
 514                 return false;
 515             }
 516             fTextBlobCount = size;
 517             fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
 518             bool success = true;
 519             int i = 0;
 520             for ( ; i < fTextBlobCount; i++) {
 521                 fTextBlobRefs[i] = SkTextBlob::CreateFromBuffer(buffer);
 522                 if (NULL == fTextBlobRefs[i]) {
 523                     success = false;
 524                     break;
 525                 }
 526             }
 527             if (!success) {
 528                 // Delete all of the blobs that were already created (up to but excluding i):
 529                 for (int j = 0; j < i; j++) {
 530                     fTextBlobRefs[j]->unref();
 531                 }
 532                 // Delete the array
 533                 SkDELETE_ARRAY(fTextBlobRefs);
 534                 fTextBlobRefs = NULL;
 535                 fTextBlobCount = 0;
 536                 return false;
 537             }
 538         } break;
 539         case SK_PICT_READER_TAG: {
 540             SkAutoDataUnref data(SkData::NewUninitialized(size));
 541             if (!buffer.readByteArray(data->writable_data(), size) ||
 542                 !buffer.validate(NULL == fOpData)) {
 543                 return false;
 544             }
 545             SkASSERT(NULL == fOpData);
 546             fOpData = data.detach();
 547         } break;
 548         case SK_PICT_PICTURE_TAG: {
 549             if (!buffer.validate((0 == fPictureCount) && (NULL == fPictureRefs))) {
 550                 return false;
 551             }
 552             fPictureCount = size;
 553             fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
 554             bool success = true;
 555             int i = 0;
 556             for ( ; i < fPictureCount; i++) {
 557                 fPictureRefs[i] = SkPicture::CreateFromBuffer(buffer);
 558                 if (NULL == fPictureRefs[i]) {
 559                     success = false;
 560                     break;
 561                 }
 562             }
 563             if (!success) {
 564                 // Delete all of the pictures that were already created (up to but excluding i):
 565                 for (int j = 0; j < i; j++) {
 566                     fPictureRefs[j]->unref();
 567                 }
 568                 // Delete the array
 569                 SkDELETE_ARRAY(fPictureRefs);
 570                 fPictureCount = 0;
 571                 return false;
 572             }
 573         } break;
 574         default:
 575             // The tag was invalid.
 576             return false;
 577     }
 578     return true;    // success
 579 }
 580
 581 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
 582                                                const SkPictInfo& info,
 583                                                SkPicture::InstallPixelRefProc proc) {
 584     SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
 585
 586     if (!data->parseStream(stream, proc)) {
 587         return NULL;
 588     }
 589     return data.detach();
 590 }
 591
 592 SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
 593                                                const SkPictInfo& info) {
 594     SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
 595     buffer.setVersion(info.fVersion);
 596
 597     if (!data->parseBuffer(buffer)) {
 598         return NULL;
 599     }
 600     return data.detach();
 601 }
 602
 603 bool SkPictureData::parseStream(SkStream* stream,
 604                                 SkPicture::InstallPixelRefProc proc) {
 605     for (;;) {
 606         uint32_t tag = stream->readU32();
 607         if (SK_PICT_EOF_TAG == tag) {
 608             break;
 609         }
 610
 611         uint32_t size = stream->readU32();
 612         if (!this->parseStreamTag(stream, tag, size, proc)) {
 613             return false; // we're invalid
 614         }
 615     }
 616     return true;
 617 }
 618
 619 bool SkPictureData::parseBuffer(SkReadBuffer& buffer) {
 620     for (;;) {
 621         uint32_t tag = buffer.readUInt();
 622         if (SK_PICT_EOF_TAG == tag) {
 623             break;
 624         }
 625
 626         uint32_t size = buffer.readUInt();
 627         if (!this->parseBufferTag(buffer, tag, size)) {
 628             return false; // we're invalid
 629         }
 630     }
 631     return true;
 632 }
 633
 634 ///////////////////////////////////////////////////////////////////////////////
 635 ///////////////////////////////////////////////////////////////////////////////
 636
 637 const SkPicture::OperationList* SkPictureData::getActiveOps(const SkRect& query) const {
 638     if (NULL == fStateTree || NULL == fBoundingHierarchy) {
 639         return NULL;
 640     }
 641
 642     SkPicture::OperationList* activeOps = SkNEW(SkPicture::OperationList);
 643     fBoundingHierarchy->search(query, &(activeOps->fOps));
 644     return activeOps;
 645 }
 646
 647 #if SK_SUPPORT_GPU
 648 bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
 649                                                 int sampleCount) const {
 650     return fContentInfo.suitableForGpuRasterization(context, reason, sampleCount);
 651 }
 652
 653 bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
 654                                                 GrPixelConfig config, SkScalar dpi) const {
 655
 656     if (context != NULL) {
 657         return this->suitableForGpuRasterization(context, reason,
 658                                                  context->getRecommendedSampleCount(config, dpi));
 659     } else {
 660         return this->suitableForGpuRasterization(NULL, reason);
 661     }
 662 }
 663
 664 bool SkPictureData::suitableForLayerOptimization() const {
 665     return fContentInfo.numLayers() > 0;
 666 }
 667 #endif
 668 ///////////////////////////////////////////////////////////////////////////////
 669
 670