Simplify a little in SkRecords.h:

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 100 matching lines @@
 };
 
 #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; }             \

[tfarina, 2014/09/18 17:35:43]

why not keep non-const and const versions?

it seems more const-correctness, than:

foo* ptr() const { return ptr; }

In chromium we have been trying to have:

foo* ptr() { return ptr; }
const foo* ptr() const { return ptr; }

[mtklein, 2014/09/18 17:52:38]

Mostly this is because it is inconvenient to use the existing ACT_AS_PTR with
the handful of types in Skia which are immutable but not typically passed by
const*, like SkTypeface and here in particular SkXfermode.

If we left it as const* ptr() const, there's no way for us to get back to the
non-const SkXfermode* we'll need to be able to play the SkRecord back into an
SkCanvas.  SkCanvas::drawPatch takes an SkXfermode*, so we need to preserve its
non-constness.

Generally, if we really want to prevent getting back a non-const pointer, it's
even better to work with it as RefBox<const T> instead of RefBox<T>.  This is
how the C++ standard libary works, for example: std::unique_ptr and
std::shared_ptr both have T* get() const; methods, same sort of thing as we're
doing here.

-    operator const T*() const { return ptr; } \
-    T* operator->() { return ptr; }           \
-    const T* operator->() const { return ptr; }
+#define ACT_AS_PTR(ptr)                 \
+    operator T*() const { return ptr; } \
+    T* operator->() const { return ptr; }
 
 template <typename T>
 class RefBox : SkNoncopyable {
 public:
-    RefBox(T* obj) : fObj(SkRef(obj)) {}
-    ~RefBox() { fObj->unref(); }
+    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 {
@@ skipping 90 matching lines @@
                         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);
-//RECORD2(DrawPatch, SkPaint, paint, SkPatch, patch);
 RECORD3(DrawPicture, Optional<SkPaint>, paint,
                      RefBox<const SkPicture>, picture,
                      Optional<SkMatrix>, matrix);
 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,
@@ skipping 13 matching lines @@
                       SkScalar, x,
                       SkScalar, y);
 RECORD5(DrawTextOnPath, SkPaint, paint,
                         PODArray<char>, text,
                         size_t, byteLength,
                         SkPath, path,
                         Optional<SkMatrix>, matrix);
 
 RECORD2(DrawData, PODArray<char>, data, size_t, length);
 
+RECORD5(DrawPatch, SkPaint, paint,
+                   PODArray<SkPoint>, cubics,
+                   PODArray<SkColor>, colors,
+                   PODArray<SkPoint>, texCoords,
+                   RefBox<SkXfermode>, xmode);
+
 // 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,
@@ skipping 14 matching lines @@
     SkCanvas::VertexMode vmode;
     int vertexCount;
     PODArray<SkPoint> vertices;
     PODArray<SkPoint> texs;
     PODArray<SkColor> colors;
     SkAutoTUnref<SkXfermode> xmode;
     PODArray<uint16_t> indices;
     int indexCount;
 };
 
-struct DrawPatch {
-    static const Type kType = DrawPatch_Type;
-
-    DrawPatch(const SkPaint& paint, SkPoint cubics[12], SkColor colors[4],
-              SkPoint texCoords[4], SkXfermode* xmode)
-    : paint(paint)
-    , cubics(cubics)
-    , colors(colors)
-    , texCoords(texCoords)
-    , xmode(SkSafeRef(xmode)) { }
-
-    SkPaint paint;
-    PODArray<SkPoint> cubics;
-    PODArray<SkColor> colors;
-    PODArray<SkPoint> texCoords;
-    SkAutoTUnref<SkXfermode> xmode;
-};
-
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED