Start tracking the CTM while filling the BBH in SkRecordDraw.

src/core/SkRecordDraw.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 "SkRecordDraw.h"
 #include "SkTSort.h"
 
@@ skipping 99 matching lines @@
 // To implement this, we keep a stack of active Save blocks.  As we consume ops
 // inside the Save/Restore block, drawing ops are unioned with the bounds of
 // the block, and control ops are stashed away for later.  When we finish the
 // block with a Restore, our bounds are complete, and we go back and fill them
 // in for all the control ops we stashed away.
 class FillBounds : SkNoncopyable {
 public:
     FillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) : fBounds(record.count()) {
         // Calculate bounds for all ops.  This won't go quite in order, so we'll need
         // to store the bounds separately then feed them in to the BBH later in order.
+        fCTM.setIdentity();
         for (fCurrentOp = 0; fCurrentOp < record.count(); fCurrentOp++) {
             record.visit<void>(fCurrentOp, *this);
         }
 
         // If we have any lingering unpaired Saves, simulate restores to make
         // sure all ops in those Save blocks have their bounds calculated.
         while (!fSaveStack.isEmpty()) {
             this->popSaveBlock();
         }
 
         // Any control ops not part of any Save/Restore block draw everywhere.
         while (!fControlIndices.isEmpty()) {
             this->popControl(SkIRect::MakeLargest());
         }
 
         // Finally feed all stored bounds into the BBH.  They'll be returned in this order.
         SkASSERT(NULL != bbh);
         for (uintptr_t i = 0; i < record.count(); i++) {
             if (!fBounds[i].isEmpty()) {
                 bbh->insert((void*)i, fBounds[i], true/*ok to defer*/);
             }
         }
         bbh->flushDeferredInserts();
     }
 
     template <typename T> void operator()(const T& r) {
+        this->updateCTM(r);
         this->trackBounds(r);
     }
 
 private:
     struct SaveBounds {
         int controlOps;  // Number of control ops in this Save block, including the Save.
         SkIRect bounds;  // Bounds of everything in the block.
     };
 
+    template <typename T> void updateCTM(const T&) { /* most ops don't change the CTM */ }
+    void updateCTM(const Restore& r)   { fCTM = r.matrix; }
+    void updateCTM(const SetMatrix& r) { fCTM = r.matrix; }
+    void updateCTM(const Concat& r)    { fCTM.preConcat(r.matrix); }
+
     // The bounds of these ops must be calculated when we hit the Restore
     // from the bounds of the ops in the same Save block.
     void trackBounds(const Save&)       { this->pushSaveBlock(); }
     // TODO: bounds of SaveLayer may be more complicated?
     void trackBounds(const SaveLayer&)  { this->pushSaveBlock(); }
     void trackBounds(const Restore&)    { fBounds[fCurrentOp] = this->popSaveBlock(); }
 
     void trackBounds(const Concat&)     { this->pushControl(); }
     void trackBounds(const SetMatrix&)  { this->pushControl(); }
     void trackBounds(const ClipRect&)   { this->pushControl(); }
@@ skipping 47 matching lines @@
     void updateSaveBounds(const SkIRect& bounds) {
         // If we're in a Save block, expand its bounds to cover these bounds too.
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().bounds.join(bounds);
         }
     }
 
     SkIRect bounds(const NoOp&) { return SkIRect::MakeEmpty(); }  // NoOps don't draw anywhere.
 
     SkAutoTMalloc<SkIRect> fBounds;  // One for each op in the record.
+    SkMatrix fCTM;
     unsigned fCurrentOp;
     SkTDArray<SaveBounds> fSaveStack;
     SkTDArray<unsigned>   fControlIndices;
 };
 
 }  // namespace SkRecords
 
 void SkRecordFillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) {
     SkRecords::FillBounds(record, bbh);
 }