Rename SkDrawPictureCallback to SkPicture::AbortCallback

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 "GrContext.h"
 #include "GrLayerCache.h"
 #include "GrRecordReplaceDraw.h"
@@ skipping 37 matching lines @@
 
 // Used by GrRecordReplaceDraw. It intercepts nested drawPicture calls and
 // also draws them with replaced layers.
 class ReplaceDraw : public SkRecords::Draw {
 public:
     ReplaceDraw(SkCanvas* canvas, GrLayerCache* layerCache,
                 SkPicture const* const drawablePicts[], int drawableCount,
                 const SkPicture* topLevelPicture,
                 const SkPicture* picture,
                 const SkMatrix& initialMatrix,
-                SkDrawPictureCallback* callback,
+                SkPicture::AbortCallback* callback,
                 const unsigned* opIndices, int numIndices)
         : INHERITED(canvas, drawablePicts, NULL, drawableCount)
         , fCanvas(canvas)
         , fLayerCache(layerCache)
         , fTopLevelPicture(topLevelPicture)
         , fPicture(picture)
         , fInitialMatrix(initialMatrix)
         , fCallback(callback)
         , fIndex(0)
         , fNumReplaced(0) {
@@ skipping 16 matching lines @@
             // 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)fCanvas->getClipBounds(&query);
 
             bbh->search(query, &fOps);
 
             for (fIndex = 0; fIndex < fOps.count(); ++fIndex) {
-                if (fCallback && fCallback->abortDrawing()) {
+                if (fCallback && fCallback->abort()) {
                     return fNumReplaced;
                 }
 
                 record->visit<void>(fOps[fIndex], *this);
             }
 
         } else {
             for (fIndex = 0; fIndex < (int) record->count(); ++fIndex) {
-                if (fCallback && fCallback->abortDrawing()) {
+                if (fCallback && fCallback->abort()) {
                     return fNumReplaced;
                 }
 
                 record->visit<void>(fIndex, *this);
             }
         }
 
         return fNumReplaced;
     }
 
@@ skipping 59 matching lines @@
             return;
         }
 
         // This is a fail for layer hoisting
         this->INHERITED::operator()(sl);
 
         fOpIndexStack.pop();
     }
 
 private:
-    SkCanvas*              fCanvas;
-    GrLayerCache*          fLayerCache;
-    const SkPicture*       fTopLevelPicture;
-    const SkPicture*       fPicture;
-    const SkMatrix         fInitialMatrix;
-    SkDrawPictureCallback* fCallback;
+    SkCanvas*                 fCanvas;
+    GrLayerCache*             fLayerCache;
+    const SkPicture*          fTopLevelPicture;
+    const SkPicture*          fPicture;
+    const SkMatrix            fInitialMatrix;
+    SkPicture::AbortCallback* fCallback;
 
-    SkTDArray<unsigned>    fOps;
-    int                    fIndex;
-    int                    fNumReplaced;
+    SkTDArray<unsigned>       fOps;
+    int                       fIndex;
+    int                       fNumReplaced;
 
     // The op code indices of all the enclosing drawPicture and saveLayer calls
-    SkTDArray<unsigned>    fOpIndexStack;
+    SkTDArray<unsigned>       fOpIndexStack;
 
     typedef Draw INHERITED;
 };
 
 int GrRecordReplaceDraw(const SkPicture* picture,
                         SkCanvas* canvas,
                         GrLayerCache* layerCache,
                         const SkMatrix& initialMatrix,
-                        SkDrawPictureCallback* callback) {
+                        SkPicture::AbortCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     // TODO: drawablePicts?
     ReplaceDraw draw(canvas, layerCache, NULL, 0,
                      picture, picture,
                      initialMatrix, callback, NULL, 0);
     return draw.draw();
 }