[NOT FOR COMMIT] Fully replace SkCanvas uses.

cc/playback/discardable_image_map.cc

Index: cc/playback/discardable_image_map.cc
diff --git a/cc/playback/discardable_image_map.cc b/cc/playback/discardable_image_map.cc
index e4ae644e227528982399d5d61232ff5c21062904..919071584037b7d0cb1a37108f93996d44f13647 100644
--- a/cc/playback/discardable_image_map.cc
+++ b/cc/playback/discardable_image_map.cc
@@ -13,7 +13,9 @@
 #include "base/memory/ptr_util.h"
 #include "cc/base/math_util.h"
 #include "cc/playback/display_item_list.h"
-#include "third_party/skia/include/utils/SkNWayCanvas.h"
+#include "skia/ext/cdl_no_draw_canvas.h"
+#include "skia/ext/cdl_paint.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
@@ -56,30 +58,30 @@ namespace {
 
 // We're using an NWay canvas with no added canvases, so in effect
 // non-overridden functions are no-ops.
-class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
+class DiscardableImagesMetadataCanvas : public CdlNoDrawCanvas {
  public:
   DiscardableImagesMetadataCanvas(
       int width,
       int height,
       std::vector<std::pair<DrawImage, gfx::Rect>>* image_set)
-      : SkNWayCanvas(width, height),
+      : CdlNoDrawCanvas(width, height),
         image_set_(image_set),
         canvas_bounds_(SkRect::MakeIWH(width, height)),
         canvas_size_(width, height) {}
 
  protected:
-  // we need to "undo" the behavior of SkNWayCanvas, which will try to forward
-  // it.
-  void onDrawPicture(const SkPicture* picture,
+  // we need to "undo" the behavior of CdlNoDrawCanvas, which will ignore
+  // onDrawPicture().
+  void onDrawPicture(const CdlPicture* picture,
                      const SkMatrix* matrix,
-                     const SkPaint* paint) override {
-    SkCanvas::onDrawPicture(picture, matrix, paint);
+                     const CdlPaint* paint) override {
+    CdlCanvas::onDrawPicture(picture, matrix, paint);
   }
 
   void onDrawImage(const SkImage* image,
                    SkScalar x,
                    SkScalar y,
-                   const SkPaint* paint) override {
+                   const CdlPaint* paint) override {
     const SkMatrix& ctm = getTotalMatrix();
     AddImage(
         sk_ref_sp(image), SkRect::MakeIWH(image->width(), image->height()),
@@ -90,8 +92,8 @@ class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
   void onDrawImageRect(const SkImage* image,
                        const SkRect* src,
                        const SkRect& dst,
-                       const SkPaint* paint,
-                       SrcRectConstraint) override {
+                       const CdlPaint* paint,
+                       SkCanvas::SrcRectConstraint) override {
     const SkMatrix& ctm = getTotalMatrix();
     SkRect src_storage;
     if (!src) {
@@ -104,33 +106,43 @@ class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
     AddImage(sk_ref_sp(image), *src, MapRect(ctm, dst), matrix, paint);
   }
 
-  void onDrawImageNine(const SkImage* image,
-                       const SkIRect& center,
-                       const SkRect& dst,
-                       const SkPaint* paint) override {
-    // No cc embedder issues image nine calls.
-    NOTREACHED();
+#if CDL_ENABLED
+  int onSaveLayer(const SaveLayerRec& rec) override {
+    saved_paints_.push_back(*rec.fPaint);
+    return CdlNoDrawCanvas::onSaveLayer(rec);
+  }
+
+  int onSave() override {
+    saved_paints_.push_back(CdlPaint());
+    return CdlNoDrawCanvas::onSave();
   }
 
+  void onRestore() override {
+    DCHECK_GT(saved_paints_.size(), 0u);
+    saved_paints_.pop_back();
+    CdlNoDrawCanvas::onRestore();
+  }
+#else
   SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec& rec) override {
     saved_paints_.push_back(*rec.fPaint);
-    return SkNWayCanvas::getSaveLayerStrategy(rec);
+    return CdlNoDrawCanvas::getSaveLayerStrategy(rec);
   }
 
   void willSave() override {
     saved_paints_.push_back(SkPaint());
-    return SkNWayCanvas::willSave();
+    return CdlNoDrawCanvas::willSave();
   }
 
   void willRestore() override {
     DCHECK_GT(saved_paints_.size(), 0u);
     saved_paints_.pop_back();
-    SkNWayCanvas::willRestore();
+    CdlNoDrawCanvas::willRestore();
   }
+#endif
 
  private:
   bool ComputePaintBounds(const SkRect& rect,
-                          const SkPaint* current_paint,
+                          const CdlPaint* current_paint,
                           SkRect* paint_bounds) {
     *paint_bounds = rect;
     if (current_paint) {
@@ -152,7 +164,7 @@ class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
                 const SkRect& src_rect,
                 const SkRect& rect,
                 const SkMatrix& matrix,
-                const SkPaint* paint) {
+                const CdlPaint* paint) {
     if (!image->isLazyGenerated())
       return;
 
@@ -181,7 +193,7 @@ class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
   std::vector<std::pair<DrawImage, gfx::Rect>>* image_set_;
   const SkRect canvas_bounds_;
   const gfx::Size canvas_size_;
-  std::vector<SkPaint> saved_paints_;
+  std::vector<CdlPaint> saved_paints_;
 };
 
 }  // namespace
@@ -190,9 +202,10 @@ DiscardableImageMap::DiscardableImageMap() {}
 
 DiscardableImageMap::~DiscardableImageMap() {}
 
-std::unique_ptr<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
+std::unique_ptr<CdlCanvas> DiscardableImageMap::BeginGeneratingMetadata(
     const gfx::Size& bounds) {
   DCHECK(all_images_.empty());
+  // TODO(cdl): switch to using std::unique_ptrs?
   return base::MakeUnique<DiscardableImagesMetadataCanvas>(
       bounds.width(), bounds.height(), &all_images_);
 }