Sketch splitting SkPicture into an interface and SkBigPicture.

src/core/SkRecords.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 SkRecords_DEFINED
 #define SkRecords_DEFINED
 
@@ skipping 63 matching lines @@
     static const Type kType = T##_Type; \
 };
 
 // We try to be flexible about the types the constructors take.  Instead of requring the exact type
 // A here, we take any type Z which implicitly casts to A.  This allows the delay_copy() trick to
 // work, allowing the caller to decide whether to pass by value or by const&.
 
 #define RECORD1(T, A, a)                \
 struct T {                              \
     static const Type kType = T##_Type; \
+    T() {}                              \
     template <typename Z>               \
     T(Z a) : a(a) {}                    \
     A a;                                \
 };
 
 #define RECORD2(T, A, a, B, b)          \
 struct T {                              \
     static const Type kType = T##_Type; \
+    T() {}                              \
     template <typename Z, typename Y>   \
     T(Z a, Y b) : a(a), b(b) {}         \
     A a; B b;                           \
 };
 
 #define RECORD3(T, A, a, B, b, C, c)              \
 struct T {                                        \
     static const Type kType = T##_Type;           \
+    T() {}                                        \
     template <typename Z, typename Y, typename X> \
     T(Z a, Y b, X c) : a(a), b(b), c(c) {}        \
     A a; B b; C c;                                \
 };
 
 #define RECORD4(T, A, a, B, b, C, c, D, d)                    \
 struct T {                                                    \
     static const Type kType = T##_Type;                       \
+    T() {}                                                    \
     template <typename Z, typename Y, typename X, typename W> \
     T(Z a, Y b, X c, W d) : a(a), b(b), c(c), d(d) {}         \
     A a; B b; C c; D d;                                       \
 };
 
 #define RECORD5(T, A, a, B, b, C, c, D, d, E, e)                          \
 struct T {                                                                \
     static const Type kType = T##_Type;                                   \
+    T() {}                                                                \
     template <typename Z, typename Y, typename X, typename W, typename V> \
     T(Z a, Y b, X c, W d, V e) : a(a), b(b), c(c), d(d), e(e) {}          \
     A a; B b; C c; D d; E e;                                              \
 };
 
 #define ACT_AS_PTR(ptr)                 \
     operator T*() const { return ptr; } \
     T* operator->() const { return ptr; }
 
 template <typename T>
 class RefBox : SkNoncopyable {
 public:
+    RefBox() {}
     RefBox(T* obj) : fObj(SkSafeRef(obj)) {}
     ~RefBox() { SkSafeUnref(fObj); }
 
     ACT_AS_PTR(fObj);
 
 private:
     T* fObj;
 };
 
 // An Optional doesn't own the pointer's memory, but may need to destroy non-POD data.
 template <typename T>
 class Optional : SkNoncopyable {
 public:
+    Optional() : fPtr(nullptr) {}
     Optional(T* ptr) : fPtr(ptr) {}
     ~Optional() { if (fPtr) fPtr->~T(); }
 
     ACT_AS_PTR(fPtr);
 private:
     T* fPtr;
 };
 
 // Like Optional, but ptr must not be NULL.
 template <typename T>
 class Adopted : SkNoncopyable {
 public:
     Adopted(T* ptr) : fPtr(ptr) { SkASSERT(fPtr); }
     Adopted(Adopted* source) {
         // Transfer ownership from source to this.
         fPtr = source->fPtr;
         source->fPtr = NULL;
     }
     ~Adopted() { if (fPtr) fPtr->~T(); }
 
     ACT_AS_PTR(fPtr);
 private:
     T* fPtr;
 };
 
 // PODArray doesn't own the pointer's memory, and we assume the data is POD.
 template <typename T>
 class PODArray {
 public:
+    PODArray() {}
     PODArray(T* ptr) : fPtr(ptr) {}
     // Default copy and assign.
 
     ACT_AS_PTR(fPtr);
 private:
     T* fPtr;
 };
 
 #undef ACT_AS_PTR
 
 // Like SkBitmap, but deep copies pixels if they're not immutable.
 // Using this, we guarantee the immutability of all bitmaps we record.
 class ImmutableBitmap : SkNoncopyable {
 public:
+    ImmutableBitmap() {}
     explicit ImmutableBitmap(const SkBitmap& bitmap) {
         if (bitmap.isImmutable()) {
             fBitmap = bitmap;
         } else {
             bitmap.copyTo(&fBitmap);
         }
         fBitmap.setImmutable();
     }
 
     int width()  const { return fBitmap.width();  }
     int height() const { return fBitmap.height(); }
 
     // While the pixels are immutable, SkBitmap itself is not thread-safe, so return a copy.
     SkBitmap shallowCopy() const { return fBitmap; }
 private:
     SkBitmap fBitmap;
 };
 
 // SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
 // SkPath::cheapComputeDirection() is similar.
 // Recording is a convenient time to cache these, or we can delay it to between record and playback.
 struct PreCachedPath : public SkPath {
+    PreCachedPath() {}
     explicit PreCachedPath(const SkPath& path) : SkPath(path) {
         this->updateBoundsCache();
         SkPath::Direction junk;
         (void)this->cheapComputeDirection(&junk);
     }
 };
 
 // Like SkPath::getBounds(), SkMatrix::getType() isn't thread safe unless we precache it.
 // This may not cover all SkMatrices used by the picture (e.g. some could be hiding in a shader).
 struct TypedMatrix : public SkMatrix {
+    TypedMatrix() {}
     explicit TypedMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
         (void)this->getType();
     }
 };
 
 RECORD0(NoOp);
 
 RECORD2(Restore, SkIRect, devBounds, TypedMatrix, matrix);
 RECORD0(Save);
 RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
 
 RECORD1(SetMatrix, TypedMatrix, matrix);
 
 struct RegionOpAndAA {
+    RegionOpAndAA() {}
     RegionOpAndAA(SkRegion::Op op, bool aa) : op(op), aa(aa) {}
     SkRegion::Op op : 31;  // This really only needs to be 3, but there's no win today to do so.
     unsigned     aa :  1;  // MSVC won't pack an enum with an bool, so we call this an unsigned.
 };
 SK_COMPILE_ASSERT(sizeof(RegionOpAndAA) == 4, RegionOpAndAASize);
 
 RECORD3(ClipPath,   SkIRect, devBounds, PreCachedPath,  path, RegionOpAndAA, opAA);
 RECORD3(ClipRRect,  SkIRect, devBounds, SkRRect,       rrect, RegionOpAndAA, opAA);
 RECORD3(ClipRect,   SkIRect, devBounds, SkRect,         rect, RegionOpAndAA, opAA);
 RECORD3(ClipRegion, SkIRect, devBounds, SkRegion,     region, SkRegion::Op,    op);
@@ skipping 106 matching lines @@
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED