Replace SkProxyCanvas with SkNWayCanvas.

skia/ext/benchmarking_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/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "skia/ext/benchmarking_canvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
-#include "third_party/skia/include/utils/SkProxyCanvas.h"
+#include "third_party/skia/include/utils/SkNWayCanvas.h"
 
 namespace skia {
 
 class AutoStamper {
 public:
   AutoStamper(TimingCanvas* timing_canvas);
   ~AutoStamper();
 
 private:
   TimingCanvas* timing_canvas_;
   base::TimeTicks start_ticks_;
 };
 
-class TimingCanvas : public SkProxyCanvas {
+class TimingCanvas : public SkNWayCanvas {
 public:
   TimingCanvas(int width, int height, const BenchmarkingCanvas* track_canvas)
-      : tracking_canvas_(track_canvas) {
+      : SkNWayCanvas(width, height)
+      , tracking_canvas_(track_canvas) {
     surface_ = skia::AdoptRef(SkSurface::NewRasterN32Premul(width, height));
 
-    setProxy(surface_->getCanvas());
+    addCanvas(surface_->getCanvas());
   }
 
   ~TimingCanvas() override {}
 
   double GetTime(size_t index) {
     TimingsMap::const_iterator timing_info = timings_map_.find(index);
     return timing_info != timings_map_.end()
         ? timing_info->second.InMillisecondsF()
         : 0.0;
   }
 
   // SkCanvas overrides.
   void willSave() override {
     AutoStamper stamper(this);
-    SkProxyCanvas::willSave();
+    SkNWayCanvas::willSave();
   }
 
   SaveLayerStrategy willSaveLayer(const SkRect* bounds,
                                   const SkPaint* paint,
                                   SaveFlags flags) override {
     AutoStamper stamper(this);
-    return SkProxyCanvas::willSaveLayer(bounds, paint, flags);
+    return SkNWayCanvas::willSaveLayer(bounds, paint, flags);
   }
 
   void willRestore() override {
     AutoStamper stamper(this);
-    SkProxyCanvas::willRestore();
+    SkNWayCanvas::willRestore();
   }
 
   void onDrawPaint(const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPaint(paint);
+    SkNWayCanvas::onDrawPaint(paint);
   }
 
   void onDrawPoints(PointMode mode,
                     size_t count,
                     const SkPoint pts[],
                     const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPoints(mode, count, pts, paint);
+    SkNWayCanvas::onDrawPoints(mode, count, pts, paint);
   }
 
   void onDrawOval(const SkRect& rect, const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawOval(rect, paint);
+    SkNWayCanvas::onDrawOval(rect, paint);
   }
 
   void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawRect(rect, paint);
+    SkNWayCanvas::onDrawRect(rect, paint);
   }
 
   void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawRRect(rrect, paint);
+    SkNWayCanvas::onDrawRRect(rrect, paint);
   }
 
   void onDrawPath(const SkPath& path, const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPath(path, paint);
+    SkNWayCanvas::onDrawPath(path, paint);
   }
 
   void onDrawBitmap(const SkBitmap& bitmap,
                     SkScalar left,
                     SkScalar top,
                     const SkPaint* paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawBitmap(bitmap, left, top, paint);
+    SkNWayCanvas::onDrawBitmap(bitmap, left, top, paint);
   }
 
   void onDrawBitmapRect(const SkBitmap& bitmap,
                         const SkRect* src,
                         const SkRect& dst,
                         const SkPaint* paint,
                         DrawBitmapRectFlags flags) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawBitmapRect(bitmap, src, dst, paint, flags);
+    SkNWayCanvas::onDrawBitmapRect(bitmap, src, dst, paint, flags);
   }
 
   void onDrawSprite(const SkBitmap& bitmap,
                     int left,
                     int top,
                     const SkPaint* paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawSprite(bitmap, left, top, paint);
+    SkNWayCanvas::onDrawSprite(bitmap, left, top, paint);
   }
 
   void 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) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawVertices(vmode, vertexCount, vertices, texs, colors,
+    SkNWayCanvas::onDrawVertices(vmode, vertexCount, vertices, texs, colors,
                                   xmode, indices, indexCount, paint);
   }
 
 protected:
  void onDrawText(const void* text,
                  size_t byteLength,
                  SkScalar x,
                  SkScalar y,
                  const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawText(text, byteLength, x, y, paint);
+    SkNWayCanvas::onDrawText(text, byteLength, x, y, paint);
   }
 
   void onDrawPosText(const void* text,
                      size_t byteLength,
                      const SkPoint pos[],
                      const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPosText(text, byteLength, pos, paint);
+    SkNWayCanvas::onDrawPosText(text, byteLength, pos, paint);
   }
 
   void onDrawPosTextH(const void* text,
                       size_t byteLength,
                       const SkScalar xpos[],
                       SkScalar constY,
                       const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPosTextH(text, byteLength, xpos, constY, paint);
+    SkNWayCanvas::onDrawPosTextH(text, byteLength, xpos, constY, paint);
   }
 
   void onDrawTextOnPath(const void* text,
                         size_t byteLength,
                         const SkPath& path,
                         const SkMatrix* matrix,
                         const SkPaint& paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawTextOnPath(text, byteLength, path, matrix, paint);
+    SkNWayCanvas::onDrawTextOnPath(text, byteLength, path, matrix, paint);
   }
 
   void onClipRect(const SkRect& rect,
                   SkRegion::Op op,
                   ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onClipRect(rect, op, edge_style);
+    SkNWayCanvas::onClipRect(rect, op, edge_style);
   }
 
   void onClipRRect(const SkRRect& rrect,
                    SkRegion::Op op,
                    ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onClipRRect(rrect, op, edge_style);
+    SkNWayCanvas::onClipRRect(rrect, op, edge_style);
   }
 
   void onClipPath(const SkPath& path,
                   SkRegion::Op op,
                   ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onClipPath(path, op, edge_style);
+    SkNWayCanvas::onClipPath(path, op, edge_style);
   }
 
   void onClipRegion(const SkRegion& region, SkRegion::Op op) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onClipRegion(region, op);
+    SkNWayCanvas::onClipRegion(region, op);
   }
 
   void onDrawPicture(const SkPicture* picture,
                      const SkMatrix* matrix,
                      const SkPaint* paint) override {
     AutoStamper stamper(this);
-    SkProxyCanvas::onDrawPicture(picture, matrix, paint);
+    SkNWayCanvas::onDrawPicture(picture, matrix, paint);
   }
 
 private:
   typedef base::hash_map<size_t, base::TimeDelta> TimingsMap;
   TimingsMap timings_map_;
 
   skia::RefPtr<SkSurface> surface_;
 
   friend class AutoStamper;
   const BenchmarkingCanvas* tracking_canvas_;
@@ skipping 32 matching lines @@
   DCHECK_LT(index, static_cast<size_t>(debug_canvas_->getSize()));
   return debug_canvas_->getDrawCommandAt(index);
 }
 
 double BenchmarkingCanvas::GetTime(size_t index) {
   DCHECK_LT(index,  static_cast<size_t>(debug_canvas_->getSize()));
   return timing_canvas_->GetTime(index);
 }
 
 } // namespace skia