Port suitableForGpuRasterization to SkRecord

src/core/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
 #include "SkChunkAlloc.h"
 #include "SkRecords.h"
 #include "SkTLogic.h"
 #include "SkTemplates.h"
 
+struct SkRecordAnalysis {
+    SkRecordAnalysis()
+        : fWillPlaybackBitmaps(false)
+        , fSuitableForGpuRasterization(false) { }
+
+    bool fWillPlaybackBitmaps;
+    bool fSuitableForGpuRasterization;
+};
+
 // SkRecord (REC-ord) represents a sequence of SkCanvas calls, saved for future use.
 // These future uses may include: replay, optimization, serialization, or combinations of those.
 //
 // Though an enterprising user may find calling alloc(), append(), visit(), and mutate() enough to
 // work with SkRecord, you probably want to look at SkRecorder which presents an SkCanvas interface
 // for creating an SkRecord, and SkRecordDraw which plays an SkRecord back into another SkCanvas.
 //
 // SkRecord often looks like it's compatible with any type T, but really it's compatible with any
 // type T which has a static const SkRecords::Type kType.  That is to say, SkRecord is compatible
 // only with SkRecords::* structs defined in SkRecords.h.  Your compiler will helpfully yell if you
@@ skipping 77 matching lines @@
     T* replace(unsigned i, const SkRecords::Adopted<Existing>& proofOfAdoption) {
         SkASSERT(i < this->count());
 
         SkASSERT(Existing::kType == fTypes[i]);
         SkASSERT(proofOfAdoption == fRecords[i].ptr<Existing>());
 
         fTypes[i] = T::kType;
         return fRecords[i].set(this->allocCommand<T>());
     }
 
+    SkRecordAnalysis fAccelerationInfo;

[mtklein, 2014/08/18 16:34:58]

Let's keep this parallel to SkRecord like fWillPlaybackBitmaps used to be?  I'm
suspicious of having a public member, especially one that's not actually used by
any code in SkRecord.

[tomhudson, 2014/08/18 16:58:47]

(This was intended to be a private member with accessors; that's part of the
cleanup noted.)

Ideally this struct would be a const member of SkPicture, but as I tried to
explain last week I was reluctant to add yet another header to include/core/.
I'll throw up a version of that so you can see what it looks like.

+
 private:
     // Implementation notes!
     //
     // Logically an SkRecord is structured as an array of pointers into a big chunk of memory where
     // records representing each canvas draw call are stored:
     //
     // fRecords:  [*][*][*]...
     //             |  |  |
     //             |  |  |
     //             |  |  +---------------------------------------+
@@ skipping 102 matching lines @@
     SkChunkAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
     unsigned fCount;
     unsigned fReserved;
     const unsigned kFirstReserveCount;
 };
 
 #endif//SkRecord_DEFINED