SkRecord strawman

src/record/SkRecords.h

Index: src/record/SkRecords.h
diff --git a/src/record/SkRecords.h b/src/record/SkRecords.h
new file mode 100644
index 0000000000000000000000000000000000000000..67cfb20c4ca4005029d0b3ac02a18b0fc0638e76
--- /dev/null
+++ b/src/record/SkRecords.h
@@ -0,0 +1,209 @@
+#ifndef SkRecords_DEFINED
+#define SkRecords_DEFINED
+
+#include "SkCanvas.h"
+
+namespace SkRecords {
+
+// A list of all the types of canvas calls we can record.
+// Each of these is reified into a struct below.
+//
+// (We're using the macro-of-macro trick here to do several different things with the same list.)
+//
+// We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
+// types polymorphically.  (See SkRecord::Record::{visit,mutate} for an example.)
+#define SK_RECORD_TYPES(M)  \
+    M(Restore)              \
+    M(Save)                 \
+    M(SaveLayer)            \
+    M(Concat)               \
+    M(SetMatrix)            \
+    M(ClipPath)             \
+    M(ClipRRect)            \
+    M(ClipRect)             \
+    M(ClipRegion)           \
+    M(Clear)                \
+    M(DrawBitmap)           \
+    M(DrawBitmapMatrix)     \
+    M(DrawBitmapNine)       \
+    M(DrawBitmapRectToRect) \
+    M(DrawDRRect)           \
+    M(DrawOval)             \
+    M(DrawPaint)            \
+    M(DrawPath)             \
+    M(DrawPoints)           \
+    M(DrawPosText)          \
+    M(DrawPosTextH)         \
+    M(DrawRRect)            \
+    M(DrawRect)             \
+    M(DrawSprite)           \
+    M(DrawText)             \
+    M(DrawTextOnPath)       \
+    M(DrawVertices)
+
+// Defines SkRecords::Type, an enum of all record types.
+#define ENUM(T) T##_Type,
+enum Type { SK_RECORD_TYPES(ENUM) };
+#undef ENUM
+
+// Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
+// These should be clearer when you look at their use below.
+#define RECORD0(T)                      \
+struct T {                              \
+    static const Type kType = T##_Type; \
+    T() {}                              \
+};
+
+// 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; \
+    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; \
+    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;           \
+    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;                       \
+    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;                                   \
+    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;                                              \
+};
+
+// Like SkBitmap, but deep copies pixels if they're not immutable.
+// Using this, we guarantee the immutability of all bitmaps we record.
+class ImmutableBitmap {
+public:
+    explicit ImmutableBitmap(const SkBitmap& bitmap) {
+        if (bitmap.isImmutable()) {
+            fBitmap = bitmap;
+        } else {
+            bitmap.copyTo(&fBitmap);
+        }
+        fBitmap.setImmutable();
+    }
+
+    operator const SkBitmap& () const { return fBitmap; }
+
+private:
+    SkBitmap fBitmap;
+};
+
+// Pointers here represent either an optional value or an array if accompanied by a count.
+// None of these records manages the lifetimes of pointers, except for DrawVertices handling its
+// Xfermode specially.
+
+RECORD0(Restore);
+RECORD1(Save, SkCanvas::SaveFlags, flags);
+RECORD3(SaveLayer, SkRect*, bounds, SkPaint*, paint, SkCanvas::SaveFlags, flags);
+
+RECORD1(Concat, SkMatrix, matrix);
+RECORD1(SetMatrix, SkMatrix, matrix);
+
+RECORD3(ClipPath, SkPath, path, SkRegion::Op, op, bool, doAA);
+RECORD3(ClipRRect, SkRRect, rrect, SkRegion::Op, op, bool, doAA);
+RECORD3(ClipRect, SkRect, rect, SkRegion::Op, op, bool, doAA);
+RECORD2(ClipRegion, SkRegion, region, SkRegion::Op, op);
+
+RECORD1(Clear, SkColor, color);
+RECORD4(DrawBitmap, ImmutableBitmap, bitmap, SkScalar, left, SkScalar, top, SkPaint*, paint);
+RECORD3(DrawBitmapMatrix, ImmutableBitmap, bitmap, SkMatrix, matrix, SkPaint*, paint);
+RECORD4(DrawBitmapNine, ImmutableBitmap, bitmap, SkIRect, center, SkRect, dst, SkPaint*, paint);
+RECORD5(DrawBitmapRectToRect, ImmutableBitmap, bitmap,
+                              SkRect*, src,
+                              SkRect, dst,
+                              SkPaint*, paint,
+                              SkCanvas::DrawBitmapRectFlags, flags);
+RECORD3(DrawDRRect, SkRRect, outer, SkRRect, inner, SkPaint, paint);
+RECORD2(DrawOval, SkRect, oval, SkPaint, paint);
+RECORD1(DrawPaint, SkPaint, paint);
+RECORD2(DrawPath, SkPath, path, SkPaint, paint);
+RECORD4(DrawPoints, SkCanvas::PointMode, mode, size_t, count, SkPoint*, pts, SkPaint, paint);
+RECORD4(DrawPosText, char*, text, size_t, byteLength, SkPoint*, pos, SkPaint, paint);
+RECORD5(DrawPosTextH, char*, text,
+                      size_t, byteLength,
+                      SkScalar*, xpos,
+                      SkScalar, y,
+                      SkPaint, paint);
+RECORD2(DrawRRect, SkRRect, rrect, SkPaint, paint);
+RECORD2(DrawRect, SkRect, rect, SkPaint, paint);
+RECORD4(DrawSprite, ImmutableBitmap, bitmap, int, left, int, top, SkPaint*, paint);
+RECORD5(DrawText, char*, text, size_t, byteLength, SkScalar, x, SkScalar, y, SkPaint, paint);
+RECORD5(DrawTextOnPath, char*, text,
+                        size_t, byteLength,
+                        SkPath, path,
+                        SkMatrix*, matrix,
+                        SkPaint, paint);
+
+// This guy is so ugly we just write it manually.
+struct DrawVertices {
+    static const Type kType = DrawVertices_Type;
+
+    DrawVertices(SkCanvas::VertexMode vmode,
+                 int vertexCount,
+                 SkPoint* vertices,
+                 SkPoint* texs,
+                 SkColor* colors,
+                 SkXfermode* xmode,
+                 uint16_t* indices,
+                 int indexCount,
+                 const SkPaint& paint)
+        : vmode(vmode)
+        , vertexCount(vertexCount)
+        , vertices(vertices)
+        , texs(texs)
+        , colors(colors)
+        , xmode(SkSafeRef(xmode))
+        , indices(indices)
+        , indexCount(indexCount)
+        , paint(paint) {}
+
+    SkCanvas::VertexMode vmode;
+    int vertexCount;
+    SkPoint* vertices;
+    SkPoint* texs;
+    SkColor* colors;
+    SkAutoTUnref<SkXfermode> xmode;
+    uint16_t* indices;
+    int indexCount;
+    SkPaint paint;
+};
+
+#undef RECORD0
+#undef RECORD1
+#undef RECORD2
+#undef RECORD3
+#undef RECORD4
+#undef RECORD5
+
+}  // namespace SkRecords
+
+#endif//SkRecords_DEFINED