Minor clode cleanup

src/core/SkPicturePlayback.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 <new>
 #include "SkBBoxHierarchy.h"
 #include "SkOffsetTable.h"
@@ skipping 947 matching lines @@
             case POP_CULL:
                 canvas.popCull();
                 break;
             case CONCAT: {
                 SkMatrix matrix;
                 this->getMatrix(reader, &matrix);
                 canvas.concat(matrix);
                 break;
             }
             case DRAW_BITMAP: {
-                const SkPaint* paint = getPaint(reader);
-                const SkBitmap& bitmap = getBitmap(reader);
+                const SkPaint* paint = this->getPaint(reader);
+                const SkBitmap& bitmap = this->getBitmap(reader);
                 const SkPoint& loc = reader.skipT<SkPoint>();
                 canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint);
             } break;
             case DRAW_BITMAP_RECT_TO_RECT: {
-                const SkPaint* paint = getPaint(reader);
-                const SkBitmap& bitmap = getBitmap(reader);
+                const SkPaint* paint = this->getPaint(reader);
+                const SkBitmap& bitmap = this->getBitmap(reader);
                 const SkRect* src = this->getRectPtr(reader);   // may be null
                 const SkRect& dst = reader.skipT<SkRect>();     // required
                 SkCanvas::DrawBitmapRectFlags flags;
                 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt();
                 canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags);
             } break;
             case DRAW_BITMAP_MATRIX: {
-                const SkPaint* paint = getPaint(reader);
-                const SkBitmap& bitmap = getBitmap(reader);
+                const SkPaint* paint = this->getPaint(reader);
+                const SkBitmap& bitmap = this->getBitmap(reader);
                 SkMatrix matrix;
                 this->getMatrix(reader, &matrix);
                 canvas.drawBitmapMatrix(bitmap, matrix, paint);
             } break;
             case DRAW_BITMAP_NINE: {
-                const SkPaint* paint = getPaint(reader);
-                const SkBitmap& bitmap = getBitmap(reader);
+                const SkPaint* paint = this->getPaint(reader);
+                const SkBitmap& bitmap = this->getBitmap(reader);
                 const SkIRect& src = reader.skipT<SkIRect>();
                 const SkRect& dst = reader.skipT<SkRect>();
                 canvas.drawBitmapNine(bitmap, src, dst, paint);
             } break;
             case DRAW_CLEAR:
                 canvas.clear(reader.readInt());
                 break;
             case DRAW_DATA: {
                 size_t length = reader.readInt();
                 canvas.drawData(reader.skip(length), length);
                 // skip handles padding the read out to a multiple of 4
             } break;
             case DRAW_DRRECT: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 SkRRect outer, inner;
                 reader.readRRect(&outer);
                 reader.readRRect(&inner);
                 canvas.drawDRRect(outer, inner, paint);
             } break;
             case BEGIN_COMMENT_GROUP: {
                 const char* desc = reader.readString();
                 canvas.beginCommentGroup(desc);
             } break;
             case COMMENT: {
                 const char* kywd = reader.readString();
                 const char* value = reader.readString();
                 canvas.addComment(kywd, value);
             } break;
             case END_COMMENT_GROUP: {
                 canvas.endCommentGroup();
             } break;
             case DRAW_OVAL: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 canvas.drawOval(reader.skipT<SkRect>(), paint);
             } break;
             case DRAW_PAINT:
-                canvas.drawPaint(*getPaint(reader));
+                canvas.drawPaint(*this->getPaint(reader));
                 break;
             case DRAW_PATH: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 canvas.drawPath(getPath(reader), paint);
             } break;
             case DRAW_PICTURE:
-                canvas.drawPicture(getPicture(reader));
+                canvas.drawPicture(this->getPicture(reader));
                 break;
             case DRAW_POINTS: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 SkCanvas::PointMode mode = (SkCanvas::PointMode)reader.readInt();
                 size_t count = reader.readInt();
                 const SkPoint* pts = (const SkPoint*)reader.skip(sizeof(SkPoint) * count);
                 canvas.drawPoints(mode, count, pts, paint);
             } break;
             case DRAW_POS_TEXT: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 getText(reader, &text);
                 size_t points = reader.readInt();
                 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
                 canvas.drawPosText(text.text(), text.length(), pos, paint);
             } break;
             case DRAW_POS_TEXT_TOP_BOTTOM: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 getText(reader, &text);
                 size_t points = reader.readInt();
                 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
                 const SkScalar top = reader.readScalar();
                 const SkScalar bottom = reader.readScalar();
                 if (!canvas.quickRejectY(top, bottom)) {
                     canvas.drawPosText(text.text(), text.length(), pos, paint);
                 }
             } break;
             case DRAW_POS_TEXT_H: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 getText(reader, &text);
                 size_t xCount = reader.readInt();
                 const SkScalar constY = reader.readScalar();
                 const SkScalar* xpos = (const SkScalar*)reader.skip(xCount * sizeof(SkScalar));
                 canvas.drawPosTextH(text.text(), text.length(), xpos, constY,
                                     paint);
             } break;
             case DRAW_POS_TEXT_H_TOP_BOTTOM: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 getText(reader, &text);
                 size_t xCount = reader.readInt();
                 const SkScalar* xpos = (const SkScalar*)reader.skip((3 + xCount) * sizeof(SkScalar));
                 const SkScalar top = *xpos++;
                 const SkScalar bottom = *xpos++;
                 const SkScalar constY = *xpos++;
                 if (!canvas.quickRejectY(top, bottom)) {
                     canvas.drawPosTextH(text.text(), text.length(), xpos,
                                         constY, paint);
                 }
             } break;
             case DRAW_RECT: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 canvas.drawRect(reader.skipT<SkRect>(), paint);
             } break;
             case DRAW_RRECT: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 SkRRect rrect;
                 reader.readRRect(&rrect);
                 canvas.drawRRect(rrect, paint);
             } break;
             case DRAW_SPRITE: {
-                const SkPaint* paint = getPaint(reader);
-                const SkBitmap& bitmap = getBitmap(reader);
+                const SkPaint* paint = this->getPaint(reader);
+                const SkBitmap& bitmap = this->getBitmap(reader);
                 int left = reader.readInt();
                 int top = reader.readInt();
                 canvas.drawSprite(bitmap, left, top, paint);
             } break;
             case DRAW_TEXT: {
-                const SkPaint& paint = *getPaint(reader);
-                getText(reader, &text);
+                const SkPaint& paint = *this->getPaint(reader);
+                this->getText(reader, &text);
                 SkScalar x = reader.readScalar();
                 SkScalar y = reader.readScalar();
                 canvas.drawText(text.text(), text.length(), x, y, paint);
             } break;
             case DRAW_TEXT_TOP_BOTTOM: {
-                const SkPaint& paint = *getPaint(reader);
-                getText(reader, &text);
+                const SkPaint& paint = *this->getPaint(reader);
+                this->getText(reader, &text);
                 const SkScalar* ptr = (const SkScalar*)reader.skip(4 * sizeof(SkScalar));
                 // ptr[0] == x
                 // ptr[1] == y
                 // ptr[2] == top
                 // ptr[3] == bottom
                 if (!canvas.quickRejectY(ptr[2], ptr[3])) {
                     canvas.drawText(text.text(), text.length(), ptr[0], ptr[1],
                                     paint);
                 }
             } break;
             case DRAW_TEXT_ON_PATH: {
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 getText(reader, &text);
-                const SkPath& path = getPath(reader);
+                const SkPath& path = this->getPath(reader);
                 SkMatrix matrix;
                 this->getMatrix(reader, &matrix);
                 canvas.drawTextOnPath(text.text(), text.length(), path, &matrix, paint);
             } break;
             case DRAW_VERTICES: {
                 SkAutoTUnref<SkXfermode> xfer;
-                const SkPaint& paint = *getPaint(reader);
+                const SkPaint& paint = *this->getPaint(reader);
                 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt();
                 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt();
                 int vCount = reader.readInt();
                 const SkPoint* verts = (const SkPoint*)reader.skip(
                                                     vCount * sizeof(SkPoint));
                 const SkPoint* texs = NULL;
                 const SkColor* colors = NULL;
                 const uint16_t* indices = NULL;
                 int iCount = 0;
                 if (flags & DRAW_VERTICES_HAS_TEXS) {
@@ skipping 22 matching lines @@
             case RESTORE:
                 canvas.restore();
                 break;
             case ROTATE:
                 canvas.rotate(reader.readScalar());
                 break;
             case SAVE:
                 canvas.save((SkCanvas::SaveFlags) reader.readInt());
                 break;
             case SAVE_LAYER: {
-                const SkRect* boundsPtr = getRectPtr(reader);
-                const SkPaint* paint = getPaint(reader);
+                const SkRect* boundsPtr = this->getRectPtr(reader);
+                const SkPaint* paint = this->getPaint(reader);
                 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt());
                 } break;
             case SCALE: {
                 SkScalar sx = reader.readScalar();
                 SkScalar sy = reader.readScalar();
                 canvas.scale(sx, sy);
             } break;
             case SET_MATRIX: {
                 SkMatrix matrix;
                 this->getMatrix(reader, &matrix);
@@ skipping 544 matching lines @@
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif