Our SkPicture::Analysis visitors should recurse into nested pictures.

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"
@@ skipping 50 matching lines @@
     Expected use is to determine whether images need to be decoded before
     rasterizing a particular SkRecord.
  */
 struct BitmapTester {
     // Helpers.  These create HasMember_bitmap and HasMember_paint.
     SK_CREATE_MEMBER_DETECTOR(bitmap);
     SK_CREATE_MEMBER_DETECTOR(paint);
 
 
     // Main entry for visitor:
+    // If the command is a DrawPicture, recurse.
     // If the command has a bitmap directly, return true.
     // If the command has a paint and the paint has a bitmap, return true.
     // Otherwise, return false.
+    bool operator()(const SkRecords::DrawPicture& op) { return op.picture->willPlayBackBitmaps(); }
+
     template <typename T>
     bool operator()(const T& r) { return CheckBitmap(r); }
 
 
     // If the command has a bitmap, of course we're going to play back bitmaps.
     template <typename T>
     static SK_WHEN(HasMember_bitmap<T>, bool) CheckBitmap(const T&) { return true; }
 
     // If not, look for one in its paint (if it has a paint).
     template <typename T>
@@ skipping 21 matching lines @@
 bool WillPlaybackBitmaps(const SkRecord& record) {
     BitmapTester tester;
     for (unsigned i = 0; i < record.count(); i++) {
         if (record.visit<bool>(i, tester)) {
             return true;
         }
     }
     return false;
 }
 
+// SkRecord visitor to find recorded text.
+struct TextHunter {
+    // All ops with text have that text as a char array member named "text".

[reed1, 2014/08/20 22:30:31]

clever, and possible fragile. All the more reason to have explicit tests for
these queries.

+    SK_CREATE_MEMBER_DETECTOR(text);
+    bool operator()(const SkRecords::DrawPicture& op) { return op.picture->hasText(); }
+    template <typename T> SK_WHEN(HasMember_text<T>,  bool) operator()(const T&) { return true;  }
+    template <typename T> SK_WHEN(!HasMember_text<T>, bool) operator()(const T&) { return false; }
+};
+
+} // namespace
+
 /** SkRecords visitor to determine heuristically whether or not a SkPicture
     will be performant when rasterized on the GPU.
  */
-struct PathCounter {
+struct SkPicture::PathCounter {
     SK_CREATE_MEMBER_DETECTOR(paint);
 
     PathCounter()
         : numPaintWithPathEffectUses (0)
         , numFastPathDashEffects (0)
         , numAAConcavePaths (0)
         , numAAHairlineConcavePaths (0) {
     }
 
+    // Recurse into nested pictures.
+    void operator()(const SkRecords::DrawPicture& op) {
+        SkASSERT(op.picture->fRecord.get() != NULL);
+        const SkRecord& nested = *op.picture->fRecord;
+        for (unsigned i = 0; i < nested.count(); i++) {
+            nested.visit<void>(i, *this);
+        }
+    }
+
     void checkPaint(const SkPaint* paint) {
         if (paint && paint->getPathEffect()) {
             numPaintWithPathEffectUses++;
         }
     }
 
     void operator()(const SkRecords::DrawPoints& op) {
         this->checkPaint(&op.paint);
         const SkPathEffect* effect = op.paint.getPathEffect();
         if (effect) {
@@ skipping 19 matching lines @@
     }
 
     template <typename T>
     SK_WHEN(HasMember_paint<T>, void) operator()(const T& op) {
         this->checkPaint(AsPtr(op.paint));
     }
 
     template <typename T>
     SK_WHEN(!HasMember_paint<T>, void) operator()(const T& op) { /* do nothing */ }
 
-
     int numPaintWithPathEffectUses;
     int numFastPathDashEffects;
     int numAAConcavePaths;
     int numAAHairlineConcavePaths;
 };
 
-// SkRecord visitor to find recorded text.
-struct TextHunter {
-    // All ops with text have that text as a char array member named "text".
-    SK_CREATE_MEMBER_DETECTOR(text);
-    template <typename T> SK_WHEN(HasMember_text<T>,  bool) operator()(const T&) { return true;  }
-    template <typename T> SK_WHEN(!HasMember_text<T>, bool) operator()(const T&) { return false; }
-};
-
-} // namespace
-
 SkPicture::Analysis::Analysis(const SkRecord& record) {
     fWillPlaybackBitmaps = WillPlaybackBitmaps(record);
 
     PathCounter counter;
     for (unsigned i = 0; i < record.count(); i++) {
         record.visit<void>(i, counter);
     }
     fNumPaintWithPathEffectUses = counter.numPaintWithPathEffectUses;
     fNumFastPathDashEffects     = counter.numFastPathDashEffects;
     fNumAAConcavePaths          = counter.numAAConcavePaths;
@@ skipping 428 matching lines @@
 int SkPicture::approximateOpCount() const {
     SkASSERT(fRecord.get() || fData.get());
     if (fRecord.get()) {
         return fRecord->count();
     }
     if (fData.get()) {
         return fData->opCount();
     }
     return 0;
 }