Force SkMatrix type while recording too.

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 166 matching lines @@
 
     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:
+struct ImmutableBitmap : public SkBitmap {
     explicit ImmutableBitmap(const SkBitmap& bitmap) {
         if (bitmap.isImmutable()) {
-            fBitmap = bitmap;
+            *(SkBitmap*)this = bitmap;
         } else {
-            bitmap.copyTo(&fBitmap);
+            bitmap.copyTo(this);
         }
-        fBitmap.setImmutable();
+        this->setImmutable();
     }
+};
 
-    operator const SkBitmap& () const { return fBitmap; }
+// SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
+// Recording is a convenient time to do this, but we could delay it to between record and playback.
+struct BoundedPath : public SkPath {
+    explicit BoundedPath(const SkPath& path) : SkPath(path) {
+        this->updateBoundsCache();
+    }
+};
 
-private:
-    SkBitmap fBitmap;
+// 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 {
+    explicit TypedMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
+        (void)this->getType();
+    }
 };
 
 RECORD0(NoOp);
 
-RECORD2(Restore, SkIRect, devBounds, SkMatrix, matrix);
+RECORD2(Restore, SkIRect, devBounds, TypedMatrix, matrix);
 RECORD0(Save);
 RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
 
 RECORD1(PushCull, SkRect, rect);
 RECORD0(PopCull);
 
-RECORD1(SetMatrix, SkMatrix, matrix);
+RECORD1(SetMatrix, TypedMatrix, matrix);
 
 struct 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, SkPath,   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);
+RECORD3(ClipPath,   SkIRect, devBounds, BoundedPath, 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);
 
 RECORD1(Clear, SkColor, color);
 
 RECORD1(BeginCommentGroup, PODArray<char>, description);
 RECORD2(AddComment, PODArray<char>, key, PODArray<char>, value);
 RECORD0(EndCommentGroup);
 
 // 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);
+RECORD3(DrawBitmapMatrix, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, TypedMatrix, matrix);
 RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
                         ImmutableBitmap, bitmap,
                         SkIRect, center,
                         SkRect, dst);
 RECORD4(DrawBitmapRectToRect, Optional<SkPaint>, paint,
                               ImmutableBitmap, bitmap,
                               Optional<SkRect>, src,
                               SkRect, dst);
 RECORD4(DrawBitmapRectToRectBleed, Optional<SkPaint>, paint,
                                    ImmutableBitmap, bitmap,
                                    Optional<SkRect>, src,
                                    SkRect, dst);
 RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
 RECORD2(DrawDrawable, SkRect, worstCaseBounds, int32_t, index);
 RECORD4(DrawImage, Optional<SkPaint>, paint,
                    RefBox<const SkImage>, image,
                    SkScalar, left,
                    SkScalar, top);
 RECORD4(DrawImageRect, Optional<SkPaint>, paint,
                        RefBox<const SkImage>, image,
                        Optional<SkRect>, src,
                        SkRect, dst);
 RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
 RECORD1(DrawPaint, SkPaint, paint);
-RECORD2(DrawPath, SkPaint, paint, SkPath, path);
+RECORD2(DrawPath, SkPaint, paint, BoundedPath, path);
 RECORD3(DrawPicture, Optional<SkPaint>, paint,
                      RefBox<const SkPicture>, picture,
-                     Optional<SkMatrix>, matrix);
+                     TypedMatrix, matrix);
 RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, unsigned, count, SkPoint*, pts);
 RECORD4(DrawPosText, SkPaint, paint,
                      PODArray<char>, text,
                      size_t, byteLength,
                      PODArray<SkPoint>, pos);
 RECORD5(DrawPosTextH, SkPaint, paint,
                       PODArray<char>, text,
                       unsigned, byteLength,
                       SkScalar, y,
                       PODArray<SkScalar>, xpos);
 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);
 RECORD4(DrawTextBlob, SkPaint, paint,
                       RefBox<const SkTextBlob>, blob,
                       SkScalar, x,
                       SkScalar, y);
 RECORD5(DrawTextOnPath, SkPaint, paint,
                         PODArray<char>, text,
                         size_t, byteLength,
-                        SkPath, path,
-                        Optional<SkMatrix>, matrix);
+                        BoundedPath, path,
+                        TypedMatrix, 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.
@@ skipping 33 matching lines @@
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED