Add support for hoisting layers in pictures drawn with a matrix

src/gpu/GrRecordReplaceDraw.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 "GrRecordReplaceDraw.h"
 #include "SkCanvasPriv.h"
 #include "SkImage.h"
 #include "SkRecordDraw.h"
 #include "SkRecords.h"
 
 GrReplacements::ReplacementInfo* GrReplacements::newReplacement(uint32_t pictureID,
-                                                                unsigned int start,
+                                                                unsigned start,
                                                                 const SkMatrix& ctm) {
     ReplacementInfo* replacement = SkNEW_ARGS(ReplacementInfo, (pictureID, start, ctm));
     fReplacementHash.add(replacement);
     return replacement;
 }
 
 void GrReplacements::freeAll() {
     SkTDynamicHash<ReplacementInfo, ReplacementInfo::Key>::Iter iter(&fReplacementHash);
 
     for (; !iter.done(); ++iter) {
         ReplacementInfo* replacement = &(*iter);
         SkDELETE(replacement);
     }
 
     fReplacementHash.reset();
 }
 
 const GrReplacements::ReplacementInfo* GrReplacements::lookupByStart(uint32_t pictureID,
-                                                                     size_t start,
+                                                                     unsigned start,
                                                                      const SkMatrix& ctm) const {
     return fReplacementHash.find(ReplacementInfo::Key(pictureID, start, ctm));
 }
 
 static inline void draw_replacement_bitmap(const GrReplacements::ReplacementInfo* ri,
-                                           SkCanvas* canvas,
-                                           const SkMatrix& initialMatrix) {
+                                           SkCanvas* canvas) {
     SkRect src = SkRect::Make(ri->fSrcRect);
     SkRect dst = SkRect::MakeXYWH(SkIntToScalar(ri->fPos.fX),
                                   SkIntToScalar(ri->fPos.fY),
                                   SkIntToScalar(ri->fSrcRect.width()),
                                   SkIntToScalar(ri->fSrcRect.height()));
 
     canvas->save();
-    canvas->setMatrix(initialMatrix);
+    canvas->setMatrix(SkMatrix::I());
     canvas->drawImageRect(ri->fImage, &src, dst, ri->fPaint);
     canvas->restore();
 }
 
 // Used by GrRecordReplaceDraw. It intercepts nested drawPicture calls and
 // also draws them with replaced layers.
 class ReplaceDraw : public SkRecords::Draw {
 public:
     ReplaceDraw(SkCanvas* canvas,
                 SkPicture const* const drawablePicts[], int drawableCount,
@@ skipping 64 matching lines @@
         // Draw sub-pictures with the same replacement list but a different picture
         ReplaceDraw draw(fCanvas, this->drawablePicts(), this->drawableCount(),
                          dp.picture, fReplacements, fInitialMatrix, fCallback);
 
         fNumReplaced += draw.draw();
     }
     void operator()(const SkRecords::SaveLayer& sl) {
 
         // For a saveLayer command, check if it can be replaced by a drawBitmap
         // call and, if so, draw it and then update the current op index accordingly.
-        size_t startOffset;
+        unsigned startOffset;
         if (fOps.count()) {
             startOffset = fOps[fIndex];
         } else {
             startOffset = fIndex;
         }
 
         const SkMatrix& ctm = fCanvas->getTotalMatrix();
         const GrReplacements::ReplacementInfo* ri = fReplacements->lookupByStart(
                                                             fPicture->uniqueID(),
                                                             startOffset,
                                                             ctm);
 
         if (ri) {
             fNumReplaced++;
-            draw_replacement_bitmap(ri, fCanvas, fInitialMatrix);
+            draw_replacement_bitmap(ri, fCanvas);
 
             if (fPicture->fBBH.get()) {
                 while (fOps[fIndex] < ri->fStop) {
                     ++fIndex;
                 }
                 SkASSERT(fOps[fIndex] == ri->fStop);
             } else {
                 fIndex = ri->fStop;
             }
             return;
@@ skipping 22 matching lines @@
                         const GrReplacements* replacements,
                         const SkMatrix& initialMatrix,
                         SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     // TODO: drawablePicts?
     ReplaceDraw draw(canvas, NULL, 0, picture, replacements, initialMatrix, callback);
 
     return draw.draw();
 }