Implement SkRecord::willPlaybackBitmaps, cache in SkPicture

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPictureFlat.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkPictureRecorder.h"
 
 #include "SkBBHFactory.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkChunkAlloc.h"
 #include "SkDrawPictureCallback.h"
 #include "SkPaintPriv.h"
 #include "SkPicture.h"
+#include "SkRecordAnalysis.h"
 #include "SkRegion.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTime.h"
 
 #include "SkReader32.h"
 #include "SkWriter32.h"
 #include "SkRTree.h"
 #include "SkBBoxHierarchyRecord.h"
@@ skipping 93 matching lines @@
     SkASSERT(perspY == 0);
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // fRecord OK
 SkPicture::SkPicture()
     : fWidth(0)
-    , fHeight(0) {
+    , fHeight(0)
+    , fRecordWillPlayBackBitmaps(false) {
     this->needsNewGenID();
 }
 
 // fRecord OK
 SkPicture::SkPicture(int width, int height,
                      const SkPictureRecord& record,
                      bool deepCopyOps)
     : fWidth(width)
-    , fHeight(height) {
+    , fHeight(height)
+    , fRecordWillPlayBackBitmaps(false) {
     this->needsNewGenID();
 
     SkPictInfo info;
     this->createHeader(&info);
     fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (record, info, deepCopyOps)));
 }
 
 // The simplest / safest way to copy an SkRecord is to replay it into a new one.
 static SkRecord* copy(const SkRecord& src, int width, int height) {
     SkRecord* dst = SkNEW(SkRecord);
     SkRecorder recorder(dst, width, height);
     SkRecordDraw(src, &recorder);
     return dst;
 }
 
 // Create an SkPicturePlayback-backed SkPicture from an SkRecord.
 // This for compatibility with serialization code only.  This is not cheap.
 static SkPicture* backport(const SkRecord& src, int width, int height) {
     SkPictureRecorder recorder;
     SkRecordDraw(src, recorder.beginRecording(width, height));
     return recorder.endRecording();
 }
 
 // fRecord OK
 SkPicture::SkPicture(const SkPicture& src) : INHERITED() {
     this->needsNewGenID();
     fWidth = src.fWidth;
     fHeight = src.fHeight;
+    fRecordWillPlayBackBitmaps = src.fRecordWillPlayBackBitmaps;
 
     if (NULL != src.fPlayback.get()) {
         fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback)));
         fUniqueID = src.uniqueID();  // need to call method to ensure != 0
     }
 
     if (NULL != src.fRecord.get()) {
         fRecord.reset(copy(*src.fRecord, fWidth, fHeight));
         fUniqueID = src.uniqueID();  // need to call method to ensure != 0
     }
@@ skipping 12 matching lines @@
 // fRecord TODO, fix by deleting this method
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
 
     for (int i = 0; i < count; i++) {
         SkPicture* clone = &pictures[i];
 
         clone->needsNewGenID();
         clone->fWidth = fWidth;
         clone->fHeight = fHeight;
+        clone->fRecordWillPlayBackBitmaps = fRecordWillPlayBackBitmaps;
         clone->fPlayback.reset(NULL);
 
         /*  We want to copy the src's playback. However, if that hasn't been built
             yet, we need to fake a call to endRecording() without actually calling
             it (since it is destructive, and we don't want to change src).
          */
         if (fPlayback.get()) {
             if (!copyInfo.initialized) {
                 int paintCount = SafeCount(fPlayback->fPaints);
 
@@ skipping 157 matching lines @@
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
 // fRecord OK
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
     , fWidth(width)
-    , fHeight(height) {
+    , fHeight(height)
+    , fRecordWillPlayBackBitmaps(false) {
     this->needsNewGenID();
 }
 
 // fRecord OK
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
@@ skipping 119 matching lines @@
         if (NULL != reason) {
             *reason = "Missing playback object.";
         }
         return false;
     }
 
     return fPlayback->suitableForGpuRasterization(context, reason);
 }
 #endif
 
-// fRecord TODO
+// fRecord OK
 bool SkPicture::willPlayBackBitmaps() const {
+    if (fRecord.get()) {
+        return fRecordWillPlayBackBitmaps;
+    }
     if (!fPlayback.get()) {
         return false;
     }
     return fPlayback->containsBitmaps();
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 // fRecord TODO, fix by switching Android to SkDrawPictureCallback, then deleting this method
 void SkPicture::abortPlayback() {
     if (NULL == fPlayback.get()) {
@@ skipping 20 matching lines @@
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }
 
 // fRecord OK
 SkPicture::SkPicture(int width, int height, SkRecord* record)
     : fWidth(width)
     , fHeight(height)
-    , fRecord(record) {
+    , fRecord(record)
+    , fRecordWillPlayBackBitmaps(record ? SkRecordWillPlaybackBitmaps(*record) : false) {

[mtklein, 2014/07/02 15:53:08]

You can assume record != NULL here.  If you'd like, add an SkASSERT?

[tomhudson, 2014/07/02 19:21:34]

Since this is in the initializer, by the time we hit the assert we'd already
have tried to dereference NULL?

[mtklein, 2014/07/02 19:23:03]

Yeah, so doesn't make much of a difference if we guard record or not.  I'd
rather not so it doesn't look optional.

     this->needsNewGenID();
 }