SkRecord bug fixes

src/record/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 89 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;                                              \
 };
 
+// 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(); }
+
+    operator T*() { return fPtr; }
+    operator const T*() const { return fPtr; }
+private:
+    T* fPtr;
+};
+
+// PODArray doesn't own the pointer's memory, and we assume the data is POD.
+template <typename T>
+class PODArray : SkNoncopyable {
+public:
+    PODArray(T* ptr) : fPtr(ptr) {}
+
+    operator T*() { return fPtr; }
+    operator const T*() const { return fPtr; }
+private:
+    T* fPtr;
+};
+
 // 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);
+RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
 
 static const unsigned kUnsetPopOffset = 0;
 RECORD2(PushCull, SkRect, rect, unsigned, popOffset);
 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);
-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);
+RECORD4(DrawBitmap, ImmutableBitmap, bitmap,
+                    SkScalar, left,
+                    SkScalar, top,
+                    Optional<SkPaint>, paint);
+RECORD3(DrawBitmapMatrix, ImmutableBitmap, bitmap, SkMatrix, matrix, Optional<SkPaint>, paint);
+RECORD4(DrawBitmapNine, ImmutableBitmap, bitmap,
+                        SkIRect, center,
+                        SkRect, dst,
+                        Optional<SkPaint>, paint);
 RECORD5(DrawBitmapRectToRect, ImmutableBitmap, bitmap,
-                              SkRect*, src,
+                              Optional<SkRect>, src,
                               SkRect, dst,
-                              SkPaint*, paint,
+                              Optional<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,
+RECORD4(DrawPosText, PODArray<char>, text,
+                     size_t, byteLength,
+                     PODArray<SkPoint>, pos,
+                     SkPaint, paint);
+RECORD5(DrawPosTextH, PODArray<char>, text,
                       size_t, byteLength,
-                      SkScalar*, xpos,
+                      PODArray<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,
+RECORD4(DrawSprite, ImmutableBitmap, bitmap, int, left, int, top, Optional<SkPaint>, paint);
+RECORD5(DrawText, PODArray<char>, text,
+                  size_t, byteLength,
+                  SkScalar, x,
+                  SkScalar, y,
+                  SkPaint, paint);
+RECORD5(DrawTextOnPath, PODArray<char>, text,
                         size_t, byteLength,
                         SkPath, path,
-                        SkMatrix*, matrix,
+                        Optional<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;
+    PODArray<SkPoint> vertices;
+    PODArray<SkPoint> texs;
+    PODArray<SkColor> colors;
     SkAutoTUnref<SkXfermode> xmode;
-    uint16_t* indices;
+    PODArray<uint16_t> indices;
     int indexCount;
     SkPaint paint;
 };
 
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED