[NOT FOR COMMIT] Fully replace SkCanvas uses.

cc/playback/image_hijack_canvas.cc

Index: cc/playback/image_hijack_canvas.cc
diff --git a/cc/playback/image_hijack_canvas.cc b/cc/playback/image_hijack_canvas.cc
index 04b24df39db9be3c2d9fa099c4f5a2f0f3fff58b..54db4e597b70c03b19d0101ee8c55450ccd29841 100644
--- a/cc/playback/image_hijack_canvas.cc
+++ b/cc/playback/image_hijack_canvas.cc
@@ -7,6 +7,7 @@
 #include "base/optional.h"
 #include "cc/playback/discardable_image_map.h"
 #include "cc/tiles/image_decode_cache.h"
+#include "skia/ext/cdl_paint.h"
 
 namespace cc {
 namespace {
@@ -23,7 +24,7 @@ class ScopedDecodedImageLock {
                          sk_sp<const SkImage> image,
                          const SkRect& src_rect,
                          const SkMatrix& matrix,
-                         const SkPaint* paint)
+                         const CdlPaint* paint)
       : image_decode_cache_(image_decode_cache),
         draw_image_(std::move(image),
                     RoundOutRect(src_rect),
@@ -44,7 +45,7 @@ class ScopedDecodedImageLock {
   }
 
   const DecodedDrawImage& decoded_image() const { return decoded_draw_image_; }
-  const SkPaint* decoded_paint() const {
+  const CdlPaint* decoded_paint() const {
     return decoded_paint_ ? &decoded_paint_.value() : nullptr;
   }
 
@@ -52,30 +53,29 @@ class ScopedDecodedImageLock {
   ImageDecodeCache* image_decode_cache_;
   DrawImage draw_image_;
   DecodedDrawImage decoded_draw_image_;
-  base::Optional<SkPaint> decoded_paint_;
+  base::Optional<CdlPaint> decoded_paint_;
 };
 
 }  // namespace
 
-ImageHijackCanvas::ImageHijackCanvas(int width,
-                                     int height,
+ImageHijackCanvas::ImageHijackCanvas(SkCanvas* canvas,
                                      ImageDecodeCache* image_decode_cache)
-    : SkNWayCanvas(width, height), image_decode_cache_(image_decode_cache) {}
+    : CdlPassThroughCanvas(canvas), image_decode_cache_(image_decode_cache) {}
 
-void ImageHijackCanvas::onDrawPicture(const SkPicture* picture,
+void ImageHijackCanvas::onDrawPicture(const CdlPicture* picture,
                                       const SkMatrix* matrix,
-                                      const SkPaint* paint) {
+                                      const CdlPaint* paint) {
   // Ensure that pictures are unpacked by this canvas, instead of being
   // forwarded to the raster canvas.
-  SkCanvas::onDrawPicture(picture, matrix, paint);
+  CdlCanvas::onDrawPicture(picture, matrix, paint);
 }
 
 void ImageHijackCanvas::onDrawImage(const SkImage* image,
                                     SkScalar x,
                                     SkScalar y,
-                                    const SkPaint* paint) {
+                                    const CdlPaint* paint) {
   if (!image->isLazyGenerated()) {
-    SkNWayCanvas::onDrawImage(image, x, y, paint);
+    CdlPassThroughCanvas::onDrawImage(image, x, y, paint);
     return;
   }
 
@@ -90,26 +90,29 @@ void ImageHijackCanvas::onDrawImage(const SkImage* image,
 
   DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().width()));
   DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().height()));
-  const SkPaint* decoded_paint = scoped_lock.decoded_paint();
+  const CdlPaint* decoded_paint = scoped_lock.decoded_paint();
 
   bool need_scale = !decoded_image.is_scale_adjustment_identity();
   if (need_scale) {
-    SkNWayCanvas::save();
-    SkNWayCanvas::scale(1.f / (decoded_image.scale_adjustment().width()),
-                        1.f / (decoded_image.scale_adjustment().height()));
+    CdlPassThroughCanvas::save();
+    CdlPassThroughCanvas::scale(
+        1.f / (decoded_image.scale_adjustment().width()),
+        1.f / (decoded_image.scale_adjustment().height()));
   }
-  SkNWayCanvas::onDrawImage(decoded_image.image().get(), x, y, decoded_paint);
+  CdlPassThroughCanvas::onDrawImage(decoded_image.image().get(), x, y,
+                                    decoded_paint);
   if (need_scale)
-    SkNWayCanvas::restore();
+    CdlPassThroughCanvas::restore();
 }
 
-void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
-                                        const SkRect* src,
-                                        const SkRect& dst,
-                                        const SkPaint* paint,
-                                        SrcRectConstraint constraint) {
+void ImageHijackCanvas::onDrawImageRect(
+    const SkImage* image,
+    const SkRect* src,
+    const SkRect& dst,
+    const CdlPaint* paint,
+    SkCanvas::SrcRectConstraint constraint) {
   if (!image->isLazyGenerated()) {
-    SkNWayCanvas::onDrawImageRect(image, src, dst, paint, constraint);
+    CdlPassThroughCanvas::onDrawImageRect(image, src, dst, paint, constraint);
     return;
   }
 
@@ -128,7 +131,7 @@ void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
   if (!decoded_image.image())
     return;
 
-  const SkPaint* decoded_paint = scoped_lock.decoded_paint();
+  const CdlPaint* decoded_paint = scoped_lock.decoded_paint();
 
   SkRect adjusted_src =
       src->makeOffset(decoded_image.src_rect_offset().width(),
@@ -140,16 +143,10 @@ void ImageHijackCanvas::onDrawImageRect(const SkImage* image,
         adjusted_src.x() * x_scale, adjusted_src.y() * y_scale,
         adjusted_src.width() * x_scale, adjusted_src.height() * y_scale);
   }
-  SkNWayCanvas::onDrawImageRect(decoded_image.image().get(), &adjusted_src, dst,
-                                decoded_paint, constraint);
+  CdlPassThroughCanvas::onDrawImageRect(decoded_image.image().get(),
+                                        &adjusted_src, dst, decoded_paint,
+                                        constraint);
 }
 
-void ImageHijackCanvas::onDrawImageNine(const SkImage* image,
-                                        const SkIRect& center,
-                                        const SkRect& dst,
-                                        const SkPaint* paint) {
-  // No cc embedder issues image nine calls.
-  NOTREACHED();
-}
 
 }  // namespace cc