move remaining virtual draw methods to onDraw

src/core/SkRecorder.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 "SkRecorder.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
@@ skipping 98 matching lines @@
     return dst;
 }
 
 // As above, assuming and copying a terminating \0.
 template <>
 char* SkRecorder::copy(const char* src) {
     return this->copy(src, strlen(src)+1);
 }
 
 
-void SkRecorder::drawPaint(const SkPaint& paint) {
+void SkRecorder::onDrawPaint(const SkPaint& paint) {
     APPEND(DrawPaint, delay_copy(paint));
 }
 
-void SkRecorder::drawPoints(PointMode mode,
-                            size_t count,
-                            const SkPoint pts[],
-                            const SkPaint& paint) {
+void SkRecorder::onDrawPoints(PointMode mode,
+                              size_t count,
+                              const SkPoint pts[],
+                              const SkPaint& paint) {
     APPEND(DrawPoints, delay_copy(paint), mode, SkToUInt(count), this->copy(pts, count));
 }
 
-void SkRecorder::drawRect(const SkRect& rect, const SkPaint& paint) {
+void SkRecorder::onDrawRect(const SkRect& rect, const SkPaint& paint) {
     APPEND(DrawRect, delay_copy(paint), rect);
 }
 
-void SkRecorder::drawOval(const SkRect& oval, const SkPaint& paint) {
+void SkRecorder::onDrawOval(const SkRect& oval, const SkPaint& paint) {
     APPEND(DrawOval, delay_copy(paint), oval);
 }
 
-void SkRecorder::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
+void SkRecorder::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
     APPEND(DrawRRect, delay_copy(paint), rrect);
 }
 
 void SkRecorder::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
     APPEND(DrawDRRect, delay_copy(paint), outer, inner);
 }
 
 void SkRecorder::onDrawDrawable(SkCanvasDrawable* drawable) {
     if (!fDrawableList) {
         fDrawableList.reset(SkNEW(SkCanvasDrawableList));
     }
     fDrawableList->append(drawable);
     APPEND(DrawDrawable, drawable->getBounds(), fDrawableList->count() - 1);
 }
 
-void SkRecorder::drawPath(const SkPath& path, const SkPaint& paint) {
+void SkRecorder::onDrawPath(const SkPath& path, const SkPaint& paint) {
     APPEND(DrawPath, delay_copy(paint), delay_copy(path));
 }
 
-void SkRecorder::drawBitmap(const SkBitmap& bitmap,
-                            SkScalar left,
-                            SkScalar top,
-                            const SkPaint* paint) {
+void SkRecorder::onDrawBitmap(const SkBitmap& bitmap,
+                              SkScalar left,
+                              SkScalar top,
+                              const SkPaint* paint) {
     APPEND(DrawBitmap, this->copy(paint), delay_copy(bitmap), left, top);
 }
 
-void SkRecorder::drawBitmapRectToRect(const SkBitmap& bitmap,
-                                      const SkRect* src,
-                                      const SkRect& dst,
-                                      const SkPaint* paint,
-                                      DrawBitmapRectFlags flags) {
+void SkRecorder::onDrawBitmapRect(const SkBitmap& bitmap,
+                                  const SkRect* src,
+                                  const SkRect& dst,
+                                  const SkPaint* paint,
+                                  DrawBitmapRectFlags flags) {
     if (kBleed_DrawBitmapRectFlag == flags) {
         APPEND(DrawBitmapRectToRectBleed,
                this->copy(paint), delay_copy(bitmap), this->copy(src), dst);
         return;
     }
     SkASSERT(kNone_DrawBitmapRectFlag == flags);
     APPEND(DrawBitmapRectToRect,
            this->copy(paint), delay_copy(bitmap), this->copy(src), dst);
 }
 
-void SkRecorder::drawBitmapNine(const SkBitmap& bitmap,
-                                const SkIRect& center,
-                                const SkRect& dst,
-                                const SkPaint* paint) {
+void SkRecorder::onDrawBitmapNine(const SkBitmap& bitmap,
+                                  const SkIRect& center,
+                                  const SkRect& dst,
+                                  const SkPaint* paint) {
     APPEND(DrawBitmapNine, this->copy(paint), delay_copy(bitmap), center, dst);
 }
 
-void SkRecorder::drawImage(const SkImage* image, SkScalar left, SkScalar top,
-                           const SkPaint* paint) {
+void SkRecorder::onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
+                             const SkPaint* paint) {
     APPEND(DrawImage, this->copy(paint), image, left, top);
 }
 
-void SkRecorder::drawImageRect(const SkImage* image, const SkRect* src,
-                               const SkRect& dst,
-                               const SkPaint* paint) {
+void SkRecorder::onDrawImageRect(const SkImage* image, const SkRect* src,
+                                 const SkRect& dst,
+                                 const SkPaint* paint) {
     APPEND(DrawImageRect, this->copy(paint), image, this->copy(src), dst);
 }
 
-void SkRecorder::drawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint) {
+void SkRecorder::onDrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint) {
     APPEND(DrawSprite, this->copy(paint), delay_copy(bitmap), left, top);
 }
 
 void SkRecorder::onDrawText(const void* text, size_t byteLength,
                             SkScalar x, SkScalar y, const SkPaint& paint) {
     APPEND(DrawText,
            delay_copy(paint), this->copy((const char*)text, byteLength), byteLength, x, y);
 }
 
 void SkRecorder::onDrawPosText(const void* text, size_t byteLength,
@@ skipping 29 matching lines @@
 
 void SkRecorder::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint& paint) {
     APPEND(DrawTextBlob, delay_copy(paint), blob, x, y);
 }
 
 void SkRecorder::onDrawPicture(const SkPicture* pic, const SkMatrix* matrix, const SkPaint* paint) {
     APPEND(DrawPicture, this->copy(paint), pic, matrix ? *matrix : SkMatrix::I());
 }
 
-void SkRecorder::drawVertices(VertexMode vmode,
-                              int vertexCount, const SkPoint vertices[],
-                              const SkPoint texs[], const SkColor colors[],
-                              SkXfermode* xmode,
-                              const uint16_t indices[], int indexCount, const SkPaint& paint) {
+void SkRecorder::onDrawVertices(VertexMode vmode,
+                                int vertexCount, const SkPoint vertices[],
+                                const SkPoint texs[], const SkColor colors[],
+                                SkXfermode* xmode,
+                                const uint16_t indices[], int indexCount, const SkPaint& paint) {
     APPEND(DrawVertices, delay_copy(paint),
                          vmode,
                          vertexCount,
                          this->copy(vertices, vertexCount),
                          texs ? this->copy(texs, vertexCount) : NULL,
                          colors ? this->copy(colors, vertexCount) : NULL,
                          xmode,
                          this->copy(indices, indexCount),
                          indexCount);
 }
@@ skipping 63 matching lines @@
 }
 
 void SkRecorder::addComment(const char* key, const char* value) {
     APPEND(AddComment, this->copy(key), this->copy(value));
 }
 
 void SkRecorder::endCommentGroup() {
     APPEND(EndCommentGroup);
 }