Manually revert "4x allocation in PipeController is probably overkill."

src/pipe/SkGPipeWrite.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotation.h"
 #include "SkBitmapDevice.h"
@@ skipping 11 matching lines @@
 #include "SkPathEffect.h"
 #include "SkPictureFlat.h"
 #include "SkRasterizer.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkStream.h"
 #include "SkTSearch.h"
 #include "SkTypeface.h"
 #include "SkWriter32.h"
 
-#ifdef SK_DEBUG
-// When debugging, allocate snuggly.
-static const size_t kMinBlockSize = 0;
-#else
-// For peformance, make large allocations.
-static const size_t kMinBlockSize = 16 * 1024;
-#endif
-
 enum {
     kSizeOfFlatRRect = sizeof(SkRect) + 4 * sizeof(SkVector)
 };
 
 static bool isCrossProcess(uint32_t flags) {
     return SkToBool(flags & SkGPipeWriter::kCrossProcess_Flag);
 }
 
 static SkFlattenable* get_paintflat(const SkPaint& paint, unsigned paintFlat) {
     SkASSERT(paintFlat < kCount_PaintFlats);
@@ skipping 301 matching lines @@
     int flattenToIndex(SkFlattenable* obj, PaintFlats);
 
     // Common code used by drawBitmap*. Behaves differently depending on the
     // type of SkBitmapHeap being used, which is determined by the flags used.
     bool commonDrawBitmap(const SkBitmap& bm, DrawOps op, unsigned flags,
                           size_t opBytesNeeded, const SkPaint* paint);
 
     SkPaint fPaint;
     void writePaint(const SkPaint&);
 
+    class AutoPipeNotify {
+    public:
+        AutoPipeNotify(SkGPipeCanvas* canvas) : fCanvas(canvas) {}
+        ~AutoPipeNotify() { fCanvas->doNotify(); }
+    private:
+        SkGPipeCanvas* fCanvas;
+    };
+    friend class AutoPipeNotify;
+
     typedef SkCanvas INHERITED;
 };
 
 void SkGPipeCanvas::flattenFactoryNames() {
     const char* name;
     while ((name = fFactorySet->getNextAddedFactoryName()) != NULL) {
         size_t len = strlen(name);
-        if (this->needOpBytes(SkWriter32::WriteStringSize(name, len))) {
+        if (this->needOpBytes(len)) {
             this->writeOp(kDef_Factory_DrawOp);
             fWriter.writeString(name, len);
         }
     }
 }
 
 bool SkGPipeCanvas::shuttleBitmap(const SkBitmap& bm, int32_t slot) {
     SkASSERT(shouldFlattenBitmaps(fFlags));
     SkWriteBuffer buffer;
     buffer.setNamedFactoryRecorder(fFactorySet);
@@ skipping 34 matching lines @@
         }
     }
     if (replaced) {
         index = ~index;
     }
     return index;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#define MIN_BLOCK_SIZE  (16 * 1024)
 #define BITMAPS_TO_KEEP 5
 #define FLATTENABLES_TO_KEEP 10
 
 SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
                              SkWriter32* writer, uint32_t flags,
                              uint32_t width, uint32_t height)
     : SkCanvas(width, height)
     , fFactorySet(isCrossProcess(flags) ? SkNEW(SkNamedFactorySet) : NULL)
     , fWriter(*writer)
     , fFlags(flags)
@@ skipping 17 matching lines @@
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap, (fBitmapShuttle.get(), BITMAPS_TO_KEEP));
     } else {
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap,
                                  (BITMAPS_TO_KEEP, controller->numberOfReaders()));
         if (this->needOpBytes(sizeof(void*))) {
             this->writeOp(kShareBitmapHeap_DrawOp);
             fWriter.writePtr(static_cast<void*>(fBitmapHeap));
         }
     }
     fFlattenableHeap.setBitmapStorage(fBitmapHeap);
+    this->doNotify();
 }
 
 SkGPipeCanvas::~SkGPipeCanvas() {
     this->finish(true);
     SkSafeUnref(fFactorySet);
     SkSafeUnref(fBitmapHeap);
 }
 
 bool SkGPipeCanvas::needOpBytes(size_t needed) {
     if (fDone) {
         return false;
     }
 
     needed += 4;  // size of DrawOp atom
-    needed = SkTMax(kMinBlockSize, needed);
-    needed = SkAlign4(needed);
     if (fWriter.bytesWritten() + needed > fBlockSize) {
-        // We're making a new block.  First push out the current block.
+        // Before we wipe out any data that has already been written, read it
+        // out.
         this->doNotify();
-
-        void* block = fController->requestBlock(needed, &fBlockSize);
+        size_t blockSize = SkTMax<size_t>(MIN_BLOCK_SIZE, needed);
+        void* block = fController->requestBlock(blockSize, &fBlockSize);
         if (NULL == block) {
             // Do not notify the readers, which would call this function again.
             this->finish(false);
             return false;
         }
         SkASSERT(SkIsAlign4(fBlockSize));
         fWriter.reset(block, fBlockSize);
         fBytesNotified = 0;
     }
     return true;
@@ skipping 10 matching lines @@
                 this->writeOp(kDef_Typeface_DrawOp);
                 writeTypeface(&fWriter, face);
             }
         }
     }
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#define NOTIFY_SETUP(canvas)    \
+    AutoPipeNotify apn(canvas)
+
 void SkGPipeCanvas::willSave(SaveFlags flags) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes()) {
         this->writeOp(kSave_DrawOp, 0, flags);
     }
 
     this->INHERITED::willSave(flags);
 }
 
 SkCanvas::SaveLayerStrategy SkGPipeCanvas::willSaveLayer(const SkRect* bounds, const SkPaint* paint,
                                                          SaveFlags saveFlags) {
+    NOTIFY_SETUP(this);
     size_t size = 0;
     unsigned opFlags = 0;
 
     if (bounds) {
         opFlags |= kSaveLayer_HasBounds_DrawOpFlag;
         size += sizeof(SkRect);
     }
     if (paint) {
         opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
         this->writePaint(*paint);
     }
 
     if (this->needOpBytes(size)) {
         this->writeOp(kSaveLayer_DrawOp, opFlags, saveFlags);
         if (bounds) {
             fWriter.writeRect(*bounds);
         }
     }
 
     if (kNoSaveLayer == fFirstSaveLayerStackLevel){
         fFirstSaveLayerStackLevel = this->getSaveCount();
     }
 
     this->INHERITED::willSaveLayer(bounds, paint, saveFlags);
     // we don't create a layer
     return kNoLayer_SaveLayerStrategy;
 }
 
 void SkGPipeCanvas::willRestore() {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes()) {
         this->writeOp(kRestore_DrawOp);
     }
 
     if (this->getSaveCount() - 1 == fFirstSaveLayerStackLevel){
         fFirstSaveLayerStackLevel = kNoSaveLayer;
     }
 
     this->INHERITED::willRestore();
 }
@@ skipping 20 matching lines @@
 
 void SkGPipeCanvas::recordConcat(const SkMatrix& m) {
     if (this->needOpBytes(m.writeToMemory(NULL))) {
         this->writeOp(kConcat_DrawOp);
         fWriter.writeMatrix(m);
     }
 }
 
 void SkGPipeCanvas::didConcat(const SkMatrix& matrix) {
     if (!matrix.isIdentity()) {
+        NOTIFY_SETUP(this);
         switch (matrix.getType()) {
             case SkMatrix::kTranslate_Mask:
                 this->recordTranslate(matrix);
                 break;
             case SkMatrix::kScale_Mask:
                 this->recordScale(matrix);
                 break;
             default:
                 this->recordConcat(matrix);
                 break;
         }
     }
 
     this->INHERITED::didConcat(matrix);
 }
 
 void SkGPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes(matrix.writeToMemory(NULL))) {
         this->writeOp(kSetMatrix_DrawOp);
         fWriter.writeMatrix(matrix);
     }
     this->INHERITED::didSetMatrix(matrix);
 }
 
 void SkGPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op rgnOp,
                                ClipEdgeStyle edgeStyle) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes(sizeof(SkRect))) {
         unsigned flags = 0;
         if (kSoft_ClipEdgeStyle == edgeStyle) {
             flags = kClip_HasAntiAlias_DrawOpFlag;
         }
         this->writeOp(kClipRect_DrawOp, flags, rgnOp);
         fWriter.writeRect(rect);
     }
     this->INHERITED::onClipRect(rect, rgnOp, edgeStyle);
 }
 
 void SkGPipeCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op rgnOp,
                                 ClipEdgeStyle edgeStyle) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes(kSizeOfFlatRRect)) {
         unsigned flags = 0;
         if (kSoft_ClipEdgeStyle == edgeStyle) {
             flags = kClip_HasAntiAlias_DrawOpFlag;
         }
         this->writeOp(kClipRRect_DrawOp, flags, rgnOp);
         fWriter.writeRRect(rrect);
     }
     this->INHERITED::onClipRRect(rrect, rgnOp, edgeStyle);
 }
 
 void SkGPipeCanvas::onClipPath(const SkPath& path, SkRegion::Op rgnOp,
                                ClipEdgeStyle edgeStyle) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes(path.writeToMemory(NULL))) {
         unsigned flags = 0;
         if (kSoft_ClipEdgeStyle == edgeStyle) {
             flags = kClip_HasAntiAlias_DrawOpFlag;
         }
         this->writeOp(kClipPath_DrawOp, flags, rgnOp);
         fWriter.writePath(path);
     }
     // we just pass on the bounds of the path
     this->INHERITED::onClipRect(path.getBounds(), rgnOp, edgeStyle);
 }
 
 void SkGPipeCanvas::onClipRegion(const SkRegion& region, SkRegion::Op rgnOp) {
+    NOTIFY_SETUP(this);
     if (this->needOpBytes(region.writeToMemory(NULL))) {
         this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
         fWriter.writeRegion(region);
     }
     this->INHERITED::onClipRegion(region, rgnOp);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGPipeCanvas::clear(SkColor color) {
+    NOTIFY_SETUP(this);
     unsigned flags = 0;
     if (color) {
         flags |= kClear_HasColor_DrawOpFlag;
     }
     if (this->needOpBytes(sizeof(SkColor))) {
         this->writeOp(kDrawClear_DrawOp, flags, 0);
         if (color) {
             fWriter.write32(color);
         }
     }
 }
 
 void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes()) {
         this->writeOp(kDrawPaint_DrawOp);
     }
 }
 
 void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
                                const SkPoint pts[], const SkPaint& paint) {
     if (count) {
+        NOTIFY_SETUP(this);
         this->writePaint(paint);
         if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
             this->writeOp(kDrawPoints_DrawOp, mode, 0);
             fWriter.write32(SkToU32(count));
             fWriter.write(pts, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::drawOval(const SkRect& rect, const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
         this->writeOp(kDrawOval_DrawOp);
         fWriter.writeRect(rect);
     }
 }
 
 void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
         this->writeOp(kDrawRect_DrawOp);
         fWriter.writeRect(rect);
     }
 }
 
 void SkGPipeCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(kSizeOfFlatRRect)) {
         this->writeOp(kDrawRRect_DrawOp);
         fWriter.writeRRect(rrect);
     }
 }
 
 void SkGPipeCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
                                  const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(kSizeOfFlatRRect * 2)) {
         this->writeOp(kDrawDRRect_DrawOp);
         fWriter.writeRRect(outer);
         fWriter.writeRRect(inner);
     }
 }
 
 void SkGPipeCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
+    NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(path.writeToMemory(NULL))) {
         this->writeOp(kDrawPath_DrawOp);
         fWriter.writePath(path);
     }
 }
 
 bool SkGPipeCanvas::commonDrawBitmap(const SkBitmap& bm, DrawOps op,
                                      unsigned flags,
                                      size_t opBytesNeeded,
                                      const SkPaint* paint) {
-    if (fDone) {
-        return false;
-    }
-
     if (paint != NULL) {
         flags |= kDrawBitmap_HasPaint_DrawOpFlag;
         this->writePaint(*paint);
     }
-
-    // This needs to run first so its calls to needOpBytes() and writes
-    // don't interlace with the needOpBytes() and writes below.
-    SkASSERT(fBitmapHeap != NULL);
-    int32_t bitmapIndex = fBitmapHeap->insert(bm);
-    if (SkBitmapHeap::INVALID_SLOT == bitmapIndex) {
-        return false;
-    }
-
     if (this->needOpBytes(opBytesNeeded)) {
+        SkASSERT(fBitmapHeap != NULL);
+        int32_t bitmapIndex = fBitmapHeap->insert(bm);
+        if (SkBitmapHeap::INVALID_SLOT == bitmapIndex) {
+            return false;
+        }
         this->writeOp(op, flags, bitmapIndex);
         return true;
     }
     return false;
 }
 
 void SkGPipeCanvas::drawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
                                const SkPaint* paint) {
+    NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkScalar) * 2;
 
     if (this->commonDrawBitmap(bm, kDrawBitmap_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.writeScalar(left);
         fWriter.writeScalar(top);
     }
 }
 
 void SkGPipeCanvas::drawBitmapRectToRect(const SkBitmap& bm, const SkRect* src,
                                          const SkRect& dst, const SkPaint* paint,
                                          DrawBitmapRectFlags dbmrFlags) {
+    NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkRect);
     bool hasSrc = src != NULL;
     unsigned flags;
     if (hasSrc) {
         flags = kDrawBitmap_HasSrcRect_DrawOpFlag;
         opBytesNeeded += sizeof(int32_t) * 4;
     } else {
         flags = 0;
     }
     if (dbmrFlags & kBleed_DrawBitmapRectFlag) {
         flags |= kDrawBitmap_Bleed_DrawOpFlag;
     }
 
     if (this->commonDrawBitmap(bm, kDrawBitmapRectToRect_DrawOp, flags, opBytesNeeded, paint)) {
         if (hasSrc) {
             fWriter.writeRect(*src);
         }
         fWriter.writeRect(dst);
     }
 }
 
 void SkGPipeCanvas::drawBitmapMatrix(const SkBitmap& bm, const SkMatrix& matrix,
                                      const SkPaint* paint) {
+    NOTIFY_SETUP(this);
     size_t opBytesNeeded = matrix.writeToMemory(NULL);
 
     if (this->commonDrawBitmap(bm, kDrawBitmapMatrix_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.writeMatrix(matrix);
     }
 }
 
 void SkGPipeCanvas::drawBitmapNine(const SkBitmap& bm, const SkIRect& center,
                                    const SkRect& dst, const SkPaint* paint) {
+    NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(int32_t) * 4 + sizeof(SkRect);
 
     if (this->commonDrawBitmap(bm, kDrawBitmapNine_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.write32(center.fLeft);
         fWriter.write32(center.fTop);
         fWriter.write32(center.fRight);
         fWriter.write32(center.fBottom);
         fWriter.writeRect(dst);
     }
 }
 
 void SkGPipeCanvas::drawSprite(const SkBitmap& bm, int left, int top,
                                    const SkPaint* paint) {
+    NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(int32_t) * 2;
 
     if (this->commonDrawBitmap(bm, kDrawSprite_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.write32(left);
         fWriter.write32(top);
     }
 }
 
 void SkGPipeCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                const SkPaint& paint) {
     if (byteLength) {
+        NOTIFY_SETUP(this);
         this->writePaint(paint);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
             this->writeOp(kDrawText_DrawOp);
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.writeScalar(x);
             fWriter.writeScalar(y);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                   const SkPaint& paint) {
     if (byteLength) {
+        NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
             this->writeOp(kDrawPosText_DrawOp);
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(pos, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                    SkScalar constY, const SkPaint& paint) {
     if (byteLength) {
+        NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
             this->writeOp(kDrawPosTextH_DrawOp);
             fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(xpos, count * sizeof(SkScalar));
             fWriter.writeScalar(constY);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                      const SkMatrix* matrix, const SkPaint& paint) {
     if (byteLength) {
+        NOTIFY_SETUP(this);
         unsigned flags = 0;
         size_t size = 4 + SkAlign4(byteLength) + path.writeToMemory(NULL);
         if (matrix) {
             flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
             size += matrix->writeToMemory(NULL);
         }
         this->writePaint(paint);
         if (this->needOpBytes(size)) {
             this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
 
@@ skipping 15 matching lines @@
 
 void SkGPipeCanvas::drawVertices(VertexMode vmode, int vertexCount,
                                  const SkPoint vertices[], const SkPoint texs[],
                                  const SkColor colors[], SkXfermode* xfer,
                                  const uint16_t indices[], int indexCount,
                                  const SkPaint& paint) {
     if (0 == vertexCount) {
         return;
     }
 
+    NOTIFY_SETUP(this);
+    size_t size = 4 + vertexCount * sizeof(SkPoint);
     this->writePaint(paint);
-
-    unsigned flags = 0;  // flags pack with the op, so don't need extra space themselves
-
-    size_t size = 0;
-    size += 4;                             // vmode
-    size += 4;                             // vertexCount
-    size += vertexCount * sizeof(SkPoint); // vertices
+    unsigned flags = 0;
     if (texs) {
         flags |= kDrawVertices_HasTexs_DrawOpFlag;
         size += vertexCount * sizeof(SkPoint);
     }
     if (colors) {
         flags |= kDrawVertices_HasColors_DrawOpFlag;
         size += vertexCount * sizeof(SkColor);
     }
+    if (indices && indexCount > 0) {
+        flags |= kDrawVertices_HasIndices_DrawOpFlag;
+        size += 4 + SkAlign4(indexCount * sizeof(uint16_t));
+    }
     if (xfer && !SkXfermode::IsMode(xfer, SkXfermode::kModulate_Mode)) {
         flags |= kDrawVertices_HasXfermode_DrawOpFlag;
-        size += sizeof(int32_t);    // SkXfermode::Mode
-    }
-    if (indices && indexCount > 0) {
-        flags |= kDrawVertices_HasIndices_DrawOpFlag;
-        size += 4;                                        // indexCount
-        size += SkAlign4(indexCount * sizeof(uint16_t));  // indices
+        size += sizeof(int32_t);    // mode enum
     }
 
     if (this->needOpBytes(size)) {
         this->writeOp(kDrawVertices_DrawOp, flags, 0);
         fWriter.write32(vmode);
         fWriter.write32(vertexCount);
         fWriter.write(vertices, vertexCount * sizeof(SkPoint));
-        if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
+        if (texs) {
             fWriter.write(texs, vertexCount * sizeof(SkPoint));
         }
-        if (flags & kDrawVertices_HasColors_DrawOpFlag) {
+        if (colors) {
             fWriter.write(colors, vertexCount * sizeof(SkColor));
         }
         if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
             SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
-            SkAssertResult(xfer->asMode(&mode));
+            (void)xfer->asMode(&mode);
             fWriter.write32(mode);
         }
-        if (flags & kDrawVertices_HasIndices_DrawOpFlag) {
+        if (indices && indexCount > 0) {
             fWriter.write32(indexCount);
             fWriter.writePad(indices, indexCount * sizeof(uint16_t));
         }
     }
 }
 
 void SkGPipeCanvas::drawData(const void* ptr, size_t size) {
     if (size && ptr) {
+        NOTIFY_SETUP(this);
         unsigned data = 0;
         if (size < (1 << DRAWOPS_DATA_BITS)) {
             data = (unsigned)size;
         }
         if (this->needOpBytes(4 + SkAlign4(size))) {
             this->writeOp(kDrawData_DrawOp, 0, data);
             if (0 == data) {
                 fWriter.write32(SkToU32(size));
             }
             fWriter.writePad(ptr, size);
         }
     }
 }
 
 void SkGPipeCanvas::beginCommentGroup(const char* description) {
     // ignore for now
 }
 
 void SkGPipeCanvas::addComment(const char* kywd, const char* value) {
     // ignore for now
 }
 
 void SkGPipeCanvas::endCommentGroup() {
     // ignore for now
 }
 
 void SkGPipeCanvas::flushRecording(bool detachCurrentBlock) {
-    this->doNotify();
+    doNotify();
     if (detachCurrentBlock) {
         // force a new block to be requested for the next recorded command
         fBlockSize = 0;
     }
 }
 
 size_t SkGPipeCanvas::freeMemoryIfPossible(size_t bytesToFree) {
     return (NULL == fBitmapHeap) ? 0 : fBitmapHeap->freeMemoryIfPossible(bytesToFree);
 }
 
@@ skipping 219 matching lines @@
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }