Fix sub-picture layer rendering bugs

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 "SkImage.h"
 #include "SkRecordDraw.h"
+#include "SkRecords.h"
+#include "SkCanvasPriv.h"
 
-GrReplacements::ReplacementInfo* GrReplacements::push() {
-    SkDEBUGCODE(this->validate());
-    return fReplacements.push();
+GrReplacements::ReplacementInfo* GrReplacements::newReplacement(uint32_t pictureID, 
+                                                                unsigned int start,
+                                                                const SkMatrix& ctm) {
+    ReplacementInfo* replacement = SkNEW_ARGS(ReplacementInfo, (pictureID, start, ctm, true));
+    fReplacementHash.add(replacement);
+    return replacement;
 }
 
 void GrReplacements::freeAll() {
-    for (int i = 0; i < fReplacements.count(); ++i) {
-        fReplacements[i].fImage->unref();
-        SkDELETE(fReplacements[i].fPaint);
+    SkTDynamicHash<ReplacementInfo, ReplacementInfo::Key>::Iter iter(&fReplacementHash);
+
+    for (; !iter.done(); ++iter) {
+        ReplacementInfo* replacement = &(*iter);
+        SkDELETE(replacement);
     }
-    fReplacements.reset();
+
+    fReplacementHash.reset();
 }
 
-#ifdef SK_DEBUG
-void GrReplacements::validate() const {
-    // Check that the ranges are monotonically increasing and non-overlapping
-    if (fReplacements.count() > 0) {
-        SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);
-
-        for (int i = 1; i < fReplacements.count(); ++i) {
-            SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
-            SkASSERT(fReplacements[i - 1].fStop < fReplacements[i].fStart);
-        }
-    }
-}
-#endif
-
 const GrReplacements::ReplacementInfo*
-GrReplacements::lookupByStart(size_t start, int* searchStart) const {
-    SkDEBUGCODE(this->validate());
-    for (int i = *searchStart; i < fReplacements.count(); ++i) {
-        if (start == fReplacements[i].fStart) {
-            *searchStart = i + 1;
-            return &fReplacements[i];
-        } else if (start < fReplacements[i].fStart) {
-            return NULL;  // the ranges are monotonically increasing and non-overlapping
-        }
-    }
-
-    return NULL;
+GrReplacements::lookupByStart(uint32_t pictureID, size_t start, const SkMatrix& ctm) const {
+    return fReplacementHash.find(ReplacementInfo::Key(pictureID, start, ctm, true));
 }
 
 static inline void draw_replacement_bitmap(const GrReplacements::ReplacementInfo* ri,
                                            SkCanvas* canvas,
                                            const SkMatrix& initialMatrix) {
     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->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,
+                const GrReplacements* replacements,
+                const SkMatrix& initialMatrix,
+                SkDrawPictureCallback* callback,
+                const SkRecord* record,
+                uint32_t pictureID)
+        : INHERITED(canvas)
+        , fCanvas(canvas)
+        , fReplacements(replacements)
+        , fInitialMatrix(initialMatrix)
+        , fCallback(callback)
+        , fIndex(0)
+        , fRecord(record)
+        , fPictureID(pictureID) {
+    }
+
+    bool done() const { return fIndex >= fRecord->count(); }
+    void drawCur() { fRecord->visit<void>(fIndex, *this); fIndex++; }
+
+    // Same as Draw for all ops except DrawPicture.
+    template <typename T> void operator()(const T& r) {
+        this->INHERITED::operator()(r);
+    }
+    void operator()(const SkRecords::DrawPicture& dp) {
+        SkAutoCanvasMatrixPaint acmp(fCanvas, dp.matrix, dp.paint, dp.picture->cullRect());
+
+        GrRecordReplaceDraw(dp.picture,
+                            fCanvas,
+                            fReplacements,
+                            fInitialMatrix,
+                            fCallback);
+    }
+    void operator()(const SkRecords::SaveLayer& sl) {
+        const GrReplacements::ReplacementInfo* ri;
+        
+        ri = fReplacements->lookupByStart(fPictureID, fIndex, fCanvas->getTotalMatrix());
+        if (ri) {
+            draw_replacement_bitmap(ri, fCanvas, fInitialMatrix);
+            fIndex = ri->fStop;
+            return;
+        }
+
+        // This is a fail for layer hoisting
+        this->INHERITED::operator()(sl);
+    }
+
+private:
+    SkCanvas* fCanvas;
+    const GrReplacements* fReplacements;
+    const SkMatrix fInitialMatrix;
+    SkDrawPictureCallback* fCallback;
+    unsigned int fIndex;
+    const SkRecord* fRecord;
+    uint32_t fPictureID;
+
+    typedef Draw INHERITED;
+};
+
 void GrRecordReplaceDraw(const SkPicture* picture,
                          SkCanvas* canvas,
                          const GrReplacements* replacements,
                          const SkMatrix& initialMatrix,
                          SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     const SkBBoxHierarchy* bbh = picture->fBBH.get();
     const SkRecord* record = picture->fRecord.get();
     if (NULL == record) {
         return;
     }
 
-    SkRecords::Draw draw(canvas);
+    ReplaceDraw draw(canvas, replacements, initialMatrix, callback, record, picture->uniqueID());
     const GrReplacements::ReplacementInfo* ri = NULL;
-    int searchStart = 0;
 
     if (bbh) {
         // Draw only ops that affect pixels in the canvas's current clip.
         // The SkRecord and BBH were recorded in identity space.  This canvas
         // is not necessarily in that same space.  getClipBounds() returns us
         // this canvas' clip bounds transformed back into identity space, which
         // lets us query the BBH.
         SkRect query = { 0, 0, 0, 0 };
         (void)canvas->getClipBounds(&query);
 
         SkTDArray<void*> ops;
         bbh->search(query, &ops);
 
         for (int i = 0; i < ops.count(); i++) {
             if (callback && callback->abortDrawing()) {
                 return;
             }
-            ri = replacements->lookupByStart((uintptr_t)ops[i], &searchStart);
+            ri = replacements->lookupByStart(picture->uniqueID(),
+                                             (uintptr_t)ops[i],
+                                             canvas->getTotalMatrix());
             if (ri) {
                 draw_replacement_bitmap(ri, canvas, initialMatrix);
 
                 while ((uintptr_t)ops[i] < ri->fStop) {
                     ++i;
                 }
                 SkASSERT((uintptr_t)ops[i] == ri->fStop);
                 continue;
             }
 
             record->visit<void>((uintptr_t)ops[i], draw);
         }
     } else {
-        for (unsigned int i = 0; i < record->count(); ++i) {
+        while (!draw.done()) {
             if (callback && callback->abortDrawing()) {
                 return;
             }
-            ri = replacements->lookupByStart(i, &searchStart);
-            if (ri) {
-                draw_replacement_bitmap(ri, canvas, initialMatrix);
-                i = ri->fStop;
-                continue;
-            }
 
-            record->visit<void>(i, draw);
+            draw.drawCur();
         }
     }
 }