Perform SkPicture analysis lazily.

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 "SkPictureData.h"
@@ skipping 119 matching lines @@
 /** SkRecords visitor to determine heuristically whether or not a SkPicture
     will be performant when rasterized on the GPU.
  */
 struct SkPicture::PathCounter {
     SK_CREATE_MEMBER_DETECTOR(paint);
 
     PathCounter() : fNumSlowPathsAndDashEffects(0) {}
 
     // Recurse into nested pictures.
     void operator()(const SkRecords::DrawPicture& op) {
-        const SkPicture::Analysis& analysis = op.picture->fAnalysis;
+        const SkPicture::Analysis& analysis = op.picture->analysis();
         fNumSlowPathsAndDashEffects += analysis.fNumSlowPathsAndDashEffects;
     }
 
     void checkPaint(const SkPaint* paint) {
         if (paint && paint->getPathEffect()) {
             // Initially assume it's slow.
             fNumSlowPathsAndDashEffects++;
         }
     }
 
@@ skipping 280 matching lines @@
     buffer.writeRect(info.fCullRect);
     buffer.writeUInt(info.fFlags);
     if (data) {
         buffer.writeBool(true);
         data->flatten(buffer);
     } else {
         buffer.writeBool(false);
     }
 }
 
+const SkPicture::Analysis& SkPicture::analysis() const {
+    auto create = [&](){ return SkNEW_ARGS(Analysis, (*fRecord)); };
+    return *fAnalysis.get(create);
+}
+
 #if SK_SUPPORT_GPU
 bool SkPicture::suitableForGpuRasterization(GrContext*, const char **reason) const {
-    return fAnalysis.suitableForGpuRasterization(reason, 0);
+    return this->analysis().suitableForGpuRasterization(reason, 0);
 }
 #endif
 
-bool SkPicture::hasText()             const { return fAnalysis.fHasText; }
-bool SkPicture::willPlayBackBitmaps() const { return fAnalysis.fWillPlaybackBitmaps; }
+bool SkPicture::hasText()             const { return this->analysis().fHasText; }
+bool SkPicture::willPlayBackBitmaps() const { return this->analysis().fWillPlaybackBitmaps; }
 int  SkPicture::approximateOpCount()  const { return fRecord->count(); }
 
 SkPicture::SkPicture(const SkRect& cullRect,
                      SkRecord* record,
                      SnapshotArray* drawablePicts,
                      SkBBoxHierarchy* bbh,
                      AccelData* accelData,
                      size_t approxBytesUsedBySubPictures)
     : fUniqueID(0)
     , fCullRect(cullRect)
     , fRecord(record)               // Take ownership of caller's ref.
     , fDrawablePicts(drawablePicts) // Take ownership.
     , fBBH(bbh)                     // Take ownership of caller's ref.
     , fAccelData(accelData)         // Take ownership of caller's ref.
     , fApproxBytesUsedBySubPictures(approxBytesUsedBySubPictures)
-    , fAnalysis(*fRecord)
 {}
 
 
 static uint32_t gNextID = 1;
 uint32_t SkPicture::uniqueID() const {
     uint32_t id = sk_atomic_load(&fUniqueID, sk_memory_order_relaxed);
     while (id == 0) {
         uint32_t next = sk_atomic_fetch_add(&gNextID, 1u);
         if (sk_atomic_compare_exchange(&fUniqueID, &id, next,
                                        sk_memory_order_relaxed,
                                        sk_memory_order_relaxed)) {
             id = next;
         } else {
             // sk_atomic_compare_exchange replaced id with the current value of fUniqueID.
         }
     }
     return id;
 }