Force SkMatrix type while recording too.

src/core/SkRecorder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRecorder.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
@@ skipping 56 matching lines @@
 public:
     Reference(const T& x) : fX(x) {}
     operator const T&() const { return fX; }
 private:
     const T& fX;
 };
 
 template <typename T>
 static Reference<T> delay_copy(const T& x) { return Reference<T>(x); }
 
-// 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.
-static Reference<SkPath> force_path_bounds(const SkPath& p) {
-    p.updateBoundsCache();
-    return Reference<SkPath>(p);
-}
-
 // Use copy() only for optional arguments, to be copied if present or skipped if not.
 // (For most types we just pass by value and let copy constructors do their thing.)
 template <typename T>
 T* SkRecorder::copy(const T* src) {
     if (NULL == src) {
         return NULL;
     }
     return SkNEW_PLACEMENT_ARGS(fRecord->alloc<T>(), T, (*src));
 }
 
@@ skipping 64 matching lines @@
 
 void SkRecorder::onDrawDrawable(SkCanvasDrawable* drawable) {
     if (!fDrawableList) {
         fDrawableList.reset(SkNEW(SkCanvasDrawableList));
     }
     fDrawableList->append(drawable);
     APPEND(DrawDrawable, drawable->getBounds(), fDrawableList->count() - 1);
 }
 
 void SkRecorder::drawPath(const SkPath& path, const SkPaint& paint) {
-    APPEND(DrawPath, delay_copy(paint), force_path_bounds(path));
+    APPEND(DrawPath, delay_copy(paint), delay_copy(path));
 }
 
 void SkRecorder::drawBitmap(const SkBitmap& bitmap,
                             SkScalar left,
                             SkScalar top,
                             const SkPaint* paint) {
     APPEND(DrawBitmap, this->copy(paint), delay_copy(bitmap), left, top);
 }
 
 void SkRecorder::drawBitmapRectToRect(const SkBitmap& bitmap,
@@ skipping 65 matching lines @@
            constY,
            this->copy(xpos, points));
 }
 
 void SkRecorder::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                   const SkMatrix* matrix, const SkPaint& paint) {
     APPEND(DrawTextOnPath,
            delay_copy(paint),
            this->copy((const char*)text, byteLength),
            byteLength,
-           force_path_bounds(path),
-           this->copy(matrix));
+           delay_copy(path),
+           matrix ? *matrix : SkMatrix::I());
 }
 
 void SkRecorder::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint& paint) {
     APPEND(DrawTextBlob, delay_copy(paint), blob, x, y);
 }
 
 void SkRecorder::onDrawPicture(const SkPicture* pic, const SkMatrix* matrix, const SkPaint* paint) {
-    APPEND(DrawPicture, this->copy(paint), pic, this->copy(matrix));
+    APPEND(DrawPicture, this->copy(paint), pic, matrix ? *matrix : SkMatrix::I());
 }
 
 void SkRecorder::drawVertices(VertexMode vmode,
                               int vertexCount, const SkPoint vertices[],
                               const SkPoint texs[], const SkColor colors[],
                               SkXfermode* xmode,
                               const uint16_t indices[], int indexCount, const SkPaint& paint) {
     APPEND(DrawVertices, delay_copy(paint),
                          vmode,
                          vertexCount,
@@ skipping 66 matching lines @@
 
 void SkRecorder::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
     INHERITED(onClipRRect, rrect, op, edgeStyle);
     SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
     APPEND(ClipRRect, this->devBounds(), rrect, opAA);
 }
 
 void SkRecorder::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
     INHERITED(onClipPath, path, op, edgeStyle);
     SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
-    APPEND(ClipPath, this->devBounds(), force_path_bounds(path), opAA);
+    APPEND(ClipPath, this->devBounds(), delay_copy(path), opAA);
 }
 
 void SkRecorder::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
     INHERITED(onClipRegion, deviceRgn, op);
     APPEND(ClipRegion, this->devBounds(), delay_copy(deviceRgn), op);
 }
 
 void SkRecorder::beginCommentGroup(const char* description) {
     APPEND(BeginCommentGroup, this->copy(description));
 }
 
 void SkRecorder::addComment(const char* key, const char* value) {
     APPEND(AddComment, this->copy(key), this->copy(value));
 }
 
 void SkRecorder::endCommentGroup() {
     APPEND(EndCommentGroup);
 }
 
 bool SkRecorder::isDrawingToLayer() const {
     return fSaveLayerCount > 0;
 }
 
 void SkRecorder::drawData(const void* data, size_t length) {
     APPEND(DrawData, copy((const char*)data), length);
 }