Record concat as setMatrix.

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 46 matching lines @@
 // NoOps draw nothing.
 template <> void Draw::draw(const NoOp&) {}
 
 #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; }
 DRAW(Restore, restore());
 DRAW(Save, save());
 DRAW(SaveLayer, saveLayer(r.bounds, r.paint, r.flags));
 DRAW(PopCull, popCull());
 DRAW(PushCull, pushCull(r.rect));
 DRAW(Clear, clear(r.color));
-DRAW(Concat, concat(r.matrix));
 DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix)));
 
 DRAW(ClipPath, clipPath(r.path, r.op, r.doAA));
 DRAW(ClipRRect, clipRRect(r.rrect, r.op, r.doAA));
 DRAW(ClipRect, clipRect(r.rect, r.op, r.doAA));
 DRAW(ClipRegion, clipRegion(r.region, r.op));
 
 DRAW(DrawBitmap, drawBitmap(shallow_copy(r.bitmap), r.left, r.top, r.paint));
 DRAW(DrawBitmapMatrix, drawBitmapMatrix(shallow_copy(r.bitmap), r.matrix, r.paint));
 DRAW(DrawBitmapNine, drawBitmapNine(shallow_copy(r.bitmap), r.center, r.dst, r.paint));
@@ skipping 35 matching lines @@
 // 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.
         const SkIRect largest = SkIRect::MakeLargest();
-        fCTM.setIdentity();
+        fCTM = &SkMatrix::I();
         fCurrentClipBounds = largest;
         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();
         }
@@ skipping 20 matching lines @@
     }
 
 private:
     struct SaveBounds {
         int controlOps;        // Number of control ops in this Save block, including the Save.
         SkIRect bounds;        // Bounds of everything in the block.
         const SkPaint* paint;  // Unowned.  If set, adjusts the bounds of all ops in this block.
     };
 
     template <typename T> void updateCTM(const T&) { /* most ops don't change the CTM */ }
-    void updateCTM(const Restore& op)   { fCTM = op.matrix; }
-    void updateCTM(const SetMatrix& op) { fCTM = op.matrix; }
-    void updateCTM(const Concat& op)    { fCTM.preConcat(op.matrix); }
+    void updateCTM(const Restore& op)   { fCTM = &op.matrix; }
+    void updateCTM(const SetMatrix& op) { fCTM = &op.matrix; }
 
     template <typename T> void updateClipBounds(const T&) { /* most ops don't change the clip */ }
     // Each of these devBounds fields is the state of the device bounds after the op.
     // So Restore's devBounds are those bounds saved by its paired Save or SaveLayer.
     void updateClipBounds(const Restore& op)    { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const ClipPath& op)   { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const ClipRRect& op)  { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const ClipRect& op)   { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const ClipRegion& op) { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const SaveLayer& op)  {
         if (op.bounds) {
             fCurrentClipBounds.intersect(this->adjustAndMap(*op.bounds, op.paint));
         }
     }
 
     // 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(NULL); }
     // TODO: bounds of SaveLayer may be more complicated?
     void trackBounds(const SaveLayer& op)  { this->pushSaveBlock(op.paint); }
     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(); }
     void trackBounds(const ClipRRect&)  { this->pushControl(); }
     void trackBounds(const ClipPath&)   { this->pushControl(); }
     void trackBounds(const ClipRegion&) { this->pushControl(); }
 
     // For all other ops, we can calculate and store the bounds directly now.
     template <typename T> void trackBounds(const T& op) {
         fBounds[fCurrentOp] = this->bounds(op);
         this->updateSaveBounds(fBounds[fCurrentOp]);
@@ skipping 152 matching lines @@
 
         // Adjust rect for all the paints from the SaveLayers we're inside.
         for (int i = fSaveStack.count() - 1; i >= 0; i--) {
             if (!AdjustForPaint(fSaveStack[i].paint, &rect)) {
                 // Same deal as above.
                 return fCurrentClipBounds;
             }
         }
 
         // Map the rect back to device space.
-        fCTM.mapRect(&rect);
+        fCTM->mapRect(&rect);
         SkIRect devRect;
         rect.roundOut(&devRect);
 
         // Nothing can draw outside the current clip.
         // (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
         devRect.intersect(fCurrentClipBounds);
         return devRect;
     }
 
     // Conservative device bounds for each op in the SkRecord.
     SkAutoTMalloc<SkIRect> fBounds;
 
     // We walk fCurrentOp through the SkRecord, as we go using updateCTM()
     // and updateClipBounds() to maintain the exact CTM (fCTM) and conservative
     // device bounds of the current clip (fCurrentClipBounds).
     unsigned fCurrentOp;
-    SkMatrix fCTM;
+    const SkMatrix* fCTM;
     SkIRect fCurrentClipBounds;
 
     // Used to track the bounds of Save/Restore blocks and the control ops inside them.
     SkTDArray<SaveBounds> fSaveStack;
     SkTDArray<unsigned>   fControlIndices;
 };
 
 }  // namespace SkRecords
 
 void SkRecordFillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) {
     SkRecords::FillBounds(record, bbh);
 }