Update from https://crrev.com/311076

skia/ext/analysis_canvas.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkShader.h"
@@ skipping 77 matching lines @@
   if (is_forced_not_solid_)
     is_solid_color_ = false;
 }
 
 void AnalysisCanvas::SetForceNotTransparent(bool flag) {
   is_forced_not_transparent_ = flag;
   if (is_forced_not_transparent_)
     is_transparent_ = false;
 }
 
-void AnalysisCanvas::drawPaint(const SkPaint& paint) {
+void AnalysisCanvas::onDrawPaint(const SkPaint& paint) {
   SkRect rect;
   getClipBounds(&rect);
   drawRect(rect, paint);
 }
 
-void AnalysisCanvas::drawPoints(SkCanvas::PointMode mode,
-                                size_t count,
-                                const SkPoint points[],
-                                const SkPaint& paint) {
+void AnalysisCanvas::onDrawPoints(SkCanvas::PointMode mode,
+                                  size_t count,
+                                  const SkPoint points[],
+                                  const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
+void AnalysisCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
   // This recreates the early-exit logic in SkCanvas.cpp.
   SkRect scratch;
   if (paint.canComputeFastBounds() &&
       quickReject(paint.computeFastBounds(rect, &scratch))) {
     return;
   }
 
   // An extra no-op check SkCanvas.cpp doesn't do.
   if (paint.nothingToDraw())
     return;
@@ skipping 27 matching lines @@
   // - The quad is a full tile quad
   if (!is_forced_not_solid_ && IsSolidColorPaint(paint) && does_cover_canvas) {
     is_solid_color_ = true;
     color_ = paint.getColor();
   } else {
     is_solid_color_ = false;
   }
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
+void AnalysisCanvas::onDrawOval(const SkRect& oval, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawRRect(const SkRRect& rr, const SkPaint& paint) {
+void AnalysisCanvas::onDrawRRect(const SkRRect& rr, const SkPaint& paint) {
   // This should add the SkRRect to an SkPath, and call
   // drawPath, but since drawPath ignores the SkPath, just
   // do the same work here.
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
+void AnalysisCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawBitmap(const SkBitmap& bitmap,
-                                SkScalar left,
-                                SkScalar top,
-                                const SkPaint*) {
+void AnalysisCanvas::onDrawBitmap(const SkBitmap& bitmap,
+                                  SkScalar left,
+                                  SkScalar top,
+                                  const SkPaint*) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawBitmapRectToRect(const SkBitmap&,
-                                          const SkRect* src,
-                                          const SkRect& dst,
-                                          const SkPaint* paint,
-                                          DrawBitmapRectFlags flags) {
+void AnalysisCanvas::onDrawBitmapRect(const SkBitmap&,
+                                      const SkRect* src,
+                                      const SkRect& dst,
+                                      const SkPaint* paint,
+                                      DrawBitmapRectFlags flags) {
   // Call drawRect to determine transparency,
   // but reset solid color to false.
   SkPaint tmpPaint;
   if (!paint)
     paint = &tmpPaint;
   drawRect(dst, *paint);
   is_solid_color_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
-                                    const SkIRect& center,
-                                    const SkRect& dst,
-                                    const SkPaint* paint) {
+void AnalysisCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
+                                      const SkIRect& center,
+                                      const SkRect& dst,
+                                      const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawSprite(const SkBitmap& bitmap,
-                                int left,
-                                int top,
-                                const SkPaint* paint) {
+void AnalysisCanvas::onDrawSprite(const SkBitmap& bitmap,
+                                  int left,
+                                  int top,
+                                  const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawText(const void* text,
                                 size_t len,
                                 SkScalar x,
                                 SkScalar y,
                                 const SkPaint& paint) {
@@ skipping 41 matching lines @@
 }
 
 void AnalysisCanvas::onDrawDRRect(const SkRRect& outer,
                                   const SkRRect& inner,
                                   const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
-void AnalysisCanvas::drawVertices(SkCanvas::VertexMode,
-                                  int vertex_count,
-                                  const SkPoint verts[],
-                                  const SkPoint texs[],
-                                  const SkColor colors[],
-                                  SkXfermode* xmode,
-                                  const uint16_t indices[],
-                                  int index_count,
-                                  const SkPaint& paint) {
+void AnalysisCanvas::onDrawVertices(SkCanvas::VertexMode,
+                                    int vertex_count,
+                                    const SkPoint verts[],
+                                    const SkPoint texs[],
+                                    const SkColor colors[],
+                                    SkXfermode* xmode,
+                                    const uint16_t indices[],
+                                    int index_count,
+                                    const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   ++draw_op_count_;
 }
 
 // Needed for now, since SkCanvas requires a bitmap, even if it is not backed
 // by any pixels
 static SkBitmap MakeEmptyBitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
@@ skipping 146 matching lines @@
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
 
   INHERITED::willRestore();
 }
 
 }  // namespace skia