Add tracing to the SkCanvas drawFoo() methods to find long draw ops.

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkImage.h"
 #include "SkMetaData.h"
 #include "SkPathOps.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkRRect.h"
 #include "SkSmallAllocator.h"
 #include "SkSurface_Base.h"
 #include "SkTemplates.h"
 #include "SkTextBlob.h"
 #include "SkTextFormatParams.h"
 #include "SkTLazy.h"
+#include "SkTraceEvent.h"
 #include "SkUtils.h"
 
 #if SK_SUPPORT_GPU
 #include "GrRenderTarget.h"
 #endif
 
 // experimental for faster tiled drawing...
 //#define SK_ENABLE_CLIP_QUICKREJECT
 
 //#define SK_TRACE_SAVERESTORE
@@ skipping 1193 matching lines @@
             }
         } else {
             dstDev->drawDevice(iter, srcDev, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 void SkCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
                           const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawSprite()");
     if (bitmap.drawsNothing()) {
         return;
     }
     SkDEBUGCODE(bitmap.validate();)
 
     SkPaint tmp;
     if (NULL == paint) {
         paint = &tmp;
     }
 
@@ skipping 426 matching lines @@
         }
     }
 #endif
 
     return NULL;
 
 }
 
 void SkCanvas::drawDRRect(const SkRRect& outer, const SkRRect& inner,
                           const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawDRRect()");
     if (outer.isEmpty()) {
         return;
     }
     if (inner.isEmpty()) {
         this->drawRRect(outer, paint);
         return;
     }
 
     // We don't have this method (yet), but technically this is what we should
     // be able to assert...
@@ skipping 17 matching lines @@
     }
 }
 
 void SkCanvas::onDiscard() {
     if (fSurfaceBase) {
         fSurfaceBase->aboutToDraw(SkSurface::kDiscard_ContentChangeMode);
     }
 }
 
 void SkCanvas::drawPaint(const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPaint()");
     this->internalDrawPaint(paint);
 }
 
 void SkCanvas::internalDrawPaint(const SkPaint& paint) {
     LOOPER_BEGIN(paint, SkDrawFilter::kPaint_Type, NULL)
 
     while (iter.next()) {
         iter.fDevice->drawPaint(iter, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
                           const SkPaint& paint) {
+    TRACE_EVENT1("skia", "SkCanvas::drawPoints()", "count", static_cast<uint64_t>(count));
     if ((long)count <= 0) {
         return;
     }
 
     SkRect r, storage;
     const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
         // special-case 2 points (common for drawing a single line)
         if (2 == count) {
             r.set(pts[0], pts[1]);
@@ skipping 11 matching lines @@
     LOOPER_BEGIN(paint, SkDrawFilter::kPoint_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawPoints(iter, mode, count, pts, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawRect()");
     SkRect storage;
     const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
         bounds = &paint.computeFastBounds(r, &storage);
         if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     LOOPER_BEGIN(paint, SkDrawFilter::kRect_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawRect(iter, r, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawOval()");
     SkRect storage;
     const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
         bounds = &paint.computeFastBounds(oval, &storage);
         if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     LOOPER_BEGIN(paint, SkDrawFilter::kOval_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawOval(iter, oval, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawRRect()");
     SkRect storage;
     const SkRect* bounds = NULL;
     if (paint.canComputeFastBounds()) {
         bounds = &paint.computeFastBounds(rrect.getBounds(), &storage);
         if (this->quickReject(*bounds)) {
             return;
         }
     }
 
     if (rrect.isRect()) {
@@ skipping 29 matching lines @@
     LOOPER_BEGIN(paint, SkDrawFilter::kRRect_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawDRRect(iter, outer, inner, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPath()");
     if (!path.isFinite()) {
         return;
     }
 
     SkRect storage;
     const SkRect* bounds = NULL;
     if (!path.isInverseFillType() && paint.canComputeFastBounds()) {
         const SkRect& pathBounds = path.getBounds();
         bounds = &paint.computeFastBounds(pathBounds, &storage);
         if (this->quickReject(*bounds)) {
@@ skipping 13 matching lines @@
 
     while (iter.next()) {
         iter.fDevice->drawPath(iter, path, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawImage(const SkImage* image, SkScalar left, SkScalar top,
                        const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawImage()");
     image->draw(this, left, top, paint);
 }
 
 void SkCanvas::drawImageRect(const SkImage* image, const SkRect* src,
                            const SkRect& dst,
                            const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawImageRect()");
     image->drawRect(this, src, dst, paint);
 }
 
 void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
                           const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawBitmap()");
     SkDEBUGCODE(bitmap.validate();)
 
     if (NULL == paint || paint->canComputeFastBounds()) {
         SkRect bounds = {
             x, y,
             x + SkIntToScalar(bitmap.width()),
             y + SkIntToScalar(bitmap.height())
         };
         if (paint) {
             (void)paint->computeFastBounds(bounds, &bounds);
@@ skipping 37 matching lines @@
     while (iter.next()) {
         iter.fDevice->drawBitmapRect(iter, bitmap, src, dst, looper.paint(), flags);
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
                                     const SkRect& dst, const SkPaint* paint,
                                     DrawBitmapRectFlags flags) {
+    TRACE_EVENT0("skia", "SkCanvas::drawBitmapRectToRect()");
     SkDEBUGCODE(bitmap.validate();)
     this->internalDrawBitmapRect(bitmap, src, dst, paint, flags);
 }
 
 void SkCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix,
                                 const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawBitmapMatrix()");
     SkDEBUGCODE(bitmap.validate();)
     this->internalDrawBitmap(bitmap, matrix, paint);
 }
 
 void SkCanvas::internalDrawBitmapNine(const SkBitmap& bitmap,
                                       const SkIRect& center, const SkRect& dst,
                                       const SkPaint* paint) {
     if (bitmap.drawsNothing()) {
         return;
     }
@@ skipping 56 matching lines @@
             d.fLeft = dstX[x];
             d.fRight = dstX[x+1];
             this->internalDrawBitmapRect(bitmap, &s, d, paint,
                                          kNone_DrawBitmapRectFlag);
         }
     }
 }
 
 void SkCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                               const SkRect& dst, const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawBitmapNine()");
     SkDEBUGCODE(bitmap.validate();)
 
     // Need a device entry-point, so gpu can use a mesh
     this->internalDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 class SkDeviceFilteredPaint {
 public:
     SkDeviceFilteredPaint(SkBaseDevice* device, const SkPaint& paint) {
         SkBaseDevice::TextFlags flags;
@@ skipping 159 matching lines @@
         SkDeviceFilteredPaint dfp(iter.fDevice, looper.paint());
         iter.fDevice->drawTextBlob(iter, blob, x, y, dfp.paint());
     }
 
     LOOPER_END
 }
 
 // These will become non-virtual, so they always call the (virtual) onDraw... method
 void SkCanvas::drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                         const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawText()");
     this->onDrawText(text, byteLength, x, y, paint);
 }
 void SkCanvas::drawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                            const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPosText()");
     this->onDrawPosText(text, byteLength, pos, paint);
 }
 void SkCanvas::drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                             SkScalar constY, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPosTextH()");
     this->onDrawPosTextH(text, byteLength, xpos, constY, paint);
 }
 void SkCanvas::drawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                               const SkMatrix* matrix, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawTextOnPath()");
     this->onDrawTextOnPath(text, byteLength, path, matrix, paint);
 }
 void SkCanvas::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawTextBlob()");
     if (blob) {
         this->onDrawTextBlob(blob, x, y, paint);
     }
 }
 
 void SkCanvas::drawVertices(VertexMode vmode, int vertexCount,
                             const SkPoint verts[], const SkPoint texs[],
                             const SkColor colors[], SkXfermode* xmode,
                             const uint16_t indices[], int indexCount,
                             const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawVertices()");
     LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, NULL)
 
     while (iter.next()) {
         iter.fDevice->drawVertices(iter, vmode, vertexCount, verts, texs,
                                    colors, xmode, indices, indexCount,
                                    looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawPatch(const SkPoint cubics[12], const SkColor colors[4],
                          const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPatch()");
     if (NULL == cubics) {
         return;
     }
 
     // Since a patch is always within the convex hull of the control points, we discard it when its
     // bounding rectangle is completely outside the current clip.
     SkRect bounds;
     bounds.set(cubics, SkPatchUtils::kNumCtrlPts);
     if (this->quickReject(bounds)) {
         return;
@@ skipping 14 matching lines @@
     LOOPER_END
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // These methods are NOT virtual, and therefore must call back into virtual
 // methods, rather than actually drawing themselves.
 //////////////////////////////////////////////////////////////////////////////
 
 void SkCanvas::drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b,
                         SkXfermode::Mode mode) {
+    TRACE_EVENT0("skia", "SkCanvas::drawARGB()");
     SkPaint paint;
 
     paint.setARGB(a, r, g, b);
     if (SkXfermode::kSrcOver_Mode != mode) {
         paint.setXfermodeMode(mode);
     }
     this->drawPaint(paint);
 }
 
 void SkCanvas::drawColor(SkColor c, SkXfermode::Mode mode) {
+    TRACE_EVENT0("skia", "SkCanvas::drawColor()");
     SkPaint paint;
 
     paint.setColor(c);
     if (SkXfermode::kSrcOver_Mode != mode) {
         paint.setXfermodeMode(mode);
     }
     this->drawPaint(paint);
 }
 
 void SkCanvas::drawPoint(SkScalar x, SkScalar y, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPoint(SkPaint)");
     SkPoint pt;
 
     pt.set(x, y);
     this->drawPoints(kPoints_PointMode, 1, &pt, paint);
 }
 
 void SkCanvas::drawPoint(SkScalar x, SkScalar y, SkColor color) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPoint(SkColor)");
     SkPoint pt;
     SkPaint paint;
 
     pt.set(x, y);
     paint.setColor(color);
     this->drawPoints(kPoints_PointMode, 1, &pt, paint);
 }
 
 void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,
                         const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawLine()");
     SkPoint pts[2];
 
     pts[0].set(x0, y0);
     pts[1].set(x1, y1);
     this->drawPoints(kLines_PointMode, 2, pts, paint);
 }
 
 void SkCanvas::drawRectCoords(SkScalar left, SkScalar top,
                               SkScalar right, SkScalar bottom,
                               const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawRectCoords()");
     SkRect  r;
 
     r.set(left, top, right, bottom);
     this->drawRect(r, paint);
 }
 
 void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius,
                           const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawCircle()");
     if (radius < 0) {
         radius = 0;
     }
 
     SkRect  r;
     r.set(cx - radius, cy - radius, cx + radius, cy + radius);
     this->drawOval(r, paint);
 }
 
 void SkCanvas::drawRoundRect(const SkRect& r, SkScalar rx, SkScalar ry,
                              const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawRoundRect()");
     if (rx > 0 && ry > 0) {
         if (paint.canComputeFastBounds()) {
             SkRect storage;
             if (this->quickReject(paint.computeFastBounds(r, &storage))) {
                 return;
             }
         }
         SkRRect rrect;
         rrect.setRectXY(r, rx, ry);
         this->drawRRect(rrect, paint);
     } else {
         this->drawRect(r, paint);
     }
 }
 
 void SkCanvas::drawArc(const SkRect& oval, SkScalar startAngle,
                        SkScalar sweepAngle, bool useCenter,
                        const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawArc()");
     if (SkScalarAbs(sweepAngle) >= SkIntToScalar(360)) {
         this->drawOval(oval, paint);
     } else {
         SkPath  path;
         if (useCenter) {
             path.moveTo(oval.centerX(), oval.centerY());
         }
         path.arcTo(oval, startAngle, sweepAngle, !useCenter);
         if (useCenter) {
             path.close();
         }
         this->drawPath(path, paint);
     }
 }
 
 void SkCanvas::drawTextOnPathHV(const void* text, size_t byteLength,
                                 const SkPath& path, SkScalar hOffset,
                                 SkScalar vOffset, const SkPaint& paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawTextOnPathHV()");
     SkMatrix    matrix;
 
     matrix.setTranslate(hOffset, vOffset);
     this->drawTextOnPath(text, byteLength, path, &matrix, paint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 void SkCanvas::EXPERIMENTAL_optimize(const SkPicture* picture) {
     SkBaseDevice* device = this->getDevice();
     if (device) {
         device->EXPERIMENTAL_optimize(picture);
     }
 }
 
 void SkCanvas::drawPicture(const SkPicture* picture) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPicture()");
     if (picture) {
         this->onDrawPicture(picture, NULL, NULL);
     }
 }
 
 void SkCanvas::drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {
+    TRACE_EVENT0("skia", "SkCanvas::drawPicture(SkMatrix, SkPaint)");
     if (picture) {
         if (matrix && matrix->isIdentity()) {
             matrix = NULL;
         }
         this->onDrawPicture(picture, matrix, paint);
     }
 }
 
 void SkCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                              const SkPaint* paint) {
@@ skipping 125 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }