Fix bug in layer hoisting transition to SkRecord backend

src/core/SkRecordDraw.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 SkRecordDraw_DEFINED
 #define SkRecordDraw_DEFINED
 
 #include "SkBBoxHierarchy.h"
 #include "SkCanvas.h"
 #include "SkDrawPictureCallback.h"
+#include "SkMatrix.h"
 #include "SkRecord.h"
 
 // Fill a BBH to be used by SkRecordDraw to accelerate playback.
 void SkRecordFillBounds(const SkRecord&, SkBBoxHierarchy*);
 
 // Draw an SkRecord into an SkCanvas.  A convenience wrapper around SkRecords::Draw.
 void SkRecordDraw(const SkRecord&, SkCanvas*, const SkBBoxHierarchy*, SkDrawPictureCallback*);
 
 // Draw a portion of an SkRecord into an SkCanvas while replacing clears with drawRects.
-void SkRecordPartialDraw(const SkRecord&, SkCanvas*, const SkRect&, unsigned start, unsigned stop);
+// When drawing a portion of an SkRecord the CTM on the passed in canvas must be
+// the composition of the replay matrix with the record-time CTM (for the portion
+// of the record that is being replayed). For setMatrix calls to behave correctly
+// the initialCTM parameter must set to just the replay matrix.
+void SkRecordPartialDraw(const SkRecord&, SkCanvas*, const SkRect&, unsigned start, unsigned stop,
+                         const SkMatrix& initialCTM);
 
 namespace SkRecords {
 
 // This is an SkRecord visitor that will draw that SkRecord to an SkCanvas.
 class Draw : SkNoncopyable {
 public:
     explicit Draw(SkCanvas* canvas)

[mtklein, 2014/09/08 18:41:23]

Would slightly prefer

Draw(SkCanvas* canvas, const SkMatrix* initialCTM = NULL)
  : fInitialCTM(initialCTM ? *initialCTM : canvas->getTotalMatrix())
  , fCanvas(canvas) {}

Then later

PartialDraw(SkCanvas* canvas, const SkRect& rect, const SkMatrix& initalCTM)
  : INHERITED(canvas, &initialCTM), fClearRect(rect) {}

I just don't like protected members.  It can be sometimes tricky to figure out
what's going on when a far-off subclass messes around with things when you don't
expect.  This way fInitialCTM can stay private and const and so a very known
quantity.

[robertphillips, 2014/09/15 18:33:19]

Done.

         : fInitialCTM(canvas->getTotalMatrix()), fCanvas(canvas) {}
 
     template <typename T> void operator()(const T& r) {
         this->draw(r);
     }
 
+protected:
+    SkMatrix fInitialCTM;
+
 private:
     // No base case, so we'll be compile-time checked that we implement all possibilities.
     template <typename T> void draw(const T&);
 
-    const SkMatrix fInitialCTM;
     SkCanvas* fCanvas;
 };
 
 // Used by SkRecordPartialDraw.
 class PartialDraw : public Draw {
 public:
-    PartialDraw(SkCanvas* canvas, const SkRect& clearRect)
-        : INHERITED(canvas), fClearRect(clearRect) {}
+    PartialDraw(SkCanvas* canvas, const SkRect& clearRect, const SkMatrix& initialCTM)
+        : INHERITED(canvas), fClearRect(clearRect) {
+        fInitialCTM = initialCTM;
+    }
 
     // Same as Draw for all ops except Clear.
     template <typename T> void operator()(const T& r) {
         this->INHERITED::operator()(r);
     }
     void operator()(const Clear& c) {
         SkPaint p;
         p.setColor(c.color);
         DrawRect drawRect(p, fClearRect);
         this->INHERITED::operator()(drawRect);
     }
 
 private:
     const SkRect fClearRect;
     typedef Draw INHERITED;
 };
 
 }  // namespace SkRecords
 
 #endif//SkRecordDraw_DEFINED