Add EXPERIMENTAL_beginRecording() for SkRecord-based recording.

src/record/SkRecords.h

Index: src/record/SkRecords.h
diff --git a/src/record/SkRecords.h b/src/record/SkRecords.h
deleted file mode 100644
index 581ae21e0535322916b9aff63bb96abe3514b410..0000000000000000000000000000000000000000
--- a/src/record/SkRecords.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * 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
-
-#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.)
-//
-// Order doesn't technically matter here, but the compiler can generally generate better code if
-// you keep them semantically grouped, especially the Draws.  It's also nice to leave NoOp at 0.
-#define SK_RECORD_TYPES(M)                                          \
-    M(NoOp)                                                         \
-    M(Restore)                                                      \
-    M(Save)                                                         \
-    M(SaveLayer)                                                    \
-    M(PushCull)                                                     \
-    M(PopCull)                                                      \
-    M(PairedPushCull)         /*From SkRecordAnnotateCullingPairs*/ \
-    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)                                                 \
-    M(BoundedDrawPosTextH)    /*From SkRecordBoundDrawPosTextH*/
-
-// 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; \
-};
-
-// 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;                                              \
-};
-
-#define ACT_AS_PTR(ptr)                       \
-    operator T*() { return ptr; }             \
-    operator const T*() const { return ptr; } \
-    T* operator->() { return ptr; }           \
-    const T* operator->() const { return ptr; }
-
-// 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(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(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 {
-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;
-};
-
-RECORD0(NoOp);
-
-RECORD0(Restore);
-RECORD1(Save, SkCanvas::SaveFlags, flags);
-RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
-
-RECORD1(PushCull, SkRect, rect);
-RECORD0(PopCull);
-
-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);
-// While not strictly required, if you have an SkPaint, it's fastest to put it first.
-RECORD4(DrawBitmap, Optional<SkPaint>, paint,
-                    ImmutableBitmap, bitmap,
-                    SkScalar, left,
-                    SkScalar, top);
-RECORD3(DrawBitmapMatrix, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, SkMatrix, matrix);
-RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
-                        ImmutableBitmap, bitmap,
-                        SkIRect, center,
-                        SkRect, dst);
-RECORD5(DrawBitmapRectToRect, Optional<SkPaint>, paint,
-                              ImmutableBitmap, bitmap,
-                              Optional<SkRect>, src,
-                              SkRect, dst,
-                              SkCanvas::DrawBitmapRectFlags, flags);
-RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
-RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
-RECORD1(DrawPaint, SkPaint, paint);
-RECORD2(DrawPath, SkPaint, paint, SkPath, path);
-RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, size_t, count, SkPoint*, pts);
-RECORD4(DrawPosText, SkPaint, paint,
-                     PODArray<char>, text,
-                     size_t, byteLength,
-                     PODArray<SkPoint>, pos);
-RECORD5(DrawPosTextH, SkPaint, paint,
-                      PODArray<char>, text,
-                      size_t, byteLength,
-                      PODArray<SkScalar>, xpos,
-                      SkScalar, y);
-RECORD2(DrawRRect, SkPaint, paint, SkRRect, rrect);
-RECORD2(DrawRect, SkPaint, paint, SkRect, rect);
-RECORD4(DrawSprite, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, int, left, int, top);
-RECORD5(DrawText, SkPaint, paint,
-                  PODArray<char>, text,
-                  size_t, byteLength,
-                  SkScalar, x,
-                  SkScalar, y);
-RECORD5(DrawTextOnPath, SkPaint, paint,
-                        PODArray<char>, text,
-                        size_t, byteLength,
-                        SkPath, path,
-                        Optional<SkMatrix>, matrix);
-
-// This guy is so ugly we just write it manually.
-struct DrawVertices {
-    static const Type kType = DrawVertices_Type;
-
-    DrawVertices(const SkPaint& paint,
-                 SkCanvas::VertexMode vmode,
-                 int vertexCount,
-                 SkPoint* vertices,
-                 SkPoint* texs,
-                 SkColor* colors,
-                 SkXfermode* xmode,
-                 uint16_t* indices,
-                 int indexCount)
-        : paint(paint)
-        , vmode(vmode)
-        , vertexCount(vertexCount)
-        , vertices(vertices)
-        , texs(texs)
-        , colors(colors)
-        , xmode(SkSafeRef(xmode))
-        , indices(indices)
-        , indexCount(indexCount) {}
-
-    SkPaint paint;
-    SkCanvas::VertexMode vmode;
-    int vertexCount;
-    PODArray<SkPoint> vertices;
-    PODArray<SkPoint> texs;
-    PODArray<SkColor> colors;
-    SkAutoTUnref<SkXfermode> xmode;
-    PODArray<uint16_t> indices;
-    int indexCount;
-};
-
-// Records added by optimizations.
-RECORD2(PairedPushCull, Adopted<PushCull>, base, unsigned, skip);
-RECORD3(BoundedDrawPosTextH, Adopted<DrawPosTextH>, base, SkScalar, minY, SkScalar, maxY);
-
-#undef RECORD0
-#undef RECORD1
-#undef RECORD2
-#undef RECORD3
-#undef RECORD4
-#undef RECORD5
-
-}  // namespace SkRecords
-
-#endif//SkRecords_DEFINED