[NOT FOR COMMIT] Fully replace SkCanvas uses.

cc/playback/raster_source.cc

 // Copyright 2014 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 "cc/playback/raster_source.h"
 
 #include <stddef.h>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/image_hijack_canvas.h"
 #include "cc/playback/skip_image_canvas.h"
 #include "skia/ext/analysis_canvas.h"
-#include "third_party/skia/include/core/SkCanvas.h"
+#include "skia/ext/cdl_canvas.h"
 #include "third_party/skia/include/core/SkClipStack.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "skia/ext/cdl_picture_recorder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 scoped_refptr<RasterSource> RasterSource::CreateFromRecordingSource(
     const RecordingSource* other,
     bool can_use_lcd_text) {
   return make_scoped_refptr(new RasterSource(other, can_use_lcd_text));
 }
 
@@ skipping 48 matching lines @@
   raster_canvas->save();
   raster_canvas->translate(-canvas_bitmap_rect.x(), -canvas_bitmap_rect.y());
   raster_canvas->clipRect(SkRect::MakeFromIRect(raster_bounds));
   raster_canvas->scale(raster_scales.width(), raster_scales.height());
   PlaybackToCanvas(raster_canvas, settings);
   raster_canvas->restore();
 }
 
 void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas,
                                     const PlaybackSettings& settings) const {
-  if (!settings.playback_to_shared_canvas)
-    PrepareForPlaybackToCanvas(raster_canvas);
+  std::unique_ptr<CdlCanvas> playback_canvas;
 
   if (settings.skip_images) {
-    SkipImageCanvas canvas(raster_canvas);
-    RasterCommon(&canvas, nullptr);
+    // TODO(cdl): SkipImageCanvas
+    // SkipImageCanvas canvas(raster_canvas);
+    // RasterCommon(&canvas, nullptr);
+    playback_canvas.reset(new CdlPassThroughCanvas(raster_canvas));
   } else if (settings.use_image_hijack_canvas) {
-    const SkImageInfo& info = raster_canvas->imageInfo();
+    playback_canvas.reset(
+        new ImageHijackCanvas(raster_canvas, image_decode_cache_));
+  } else {
+    playback_canvas.reset(new CdlPassThroughCanvas(raster_canvas));
+  }
 
-    ImageHijackCanvas canvas(info.width(), info.height(), image_decode_cache_);
-    // Before adding the canvas, make sure that the ImageHijackCanvas is aware
-    // of the current transform and clip, which may affect the clip bounds.
-    // Since we query the clip bounds of the current canvas to get the list of
-    // draw commands to process, this is important to produce correct content.
-    SkIRect raster_bounds;
-    raster_canvas->getClipDeviceBounds(&raster_bounds);
-    canvas.clipRect(SkRect::MakeFromIRect(raster_bounds));
-    canvas.setMatrix(raster_canvas->getTotalMatrix());
-    canvas.addCanvas(raster_canvas);
+  if (!settings.playback_to_shared_canvas)
+    PrepareForPlaybackToCanvas(playback_canvas.get());
 
-    RasterCommon(&canvas, nullptr);
-  } else {
-    RasterCommon(raster_canvas, nullptr);
-  }
+  RasterCommon(playback_canvas.get(), nullptr);
 }
 
-void RasterSource::PrepareForPlaybackToCanvas(SkCanvas* canvas) const {
+void RasterSource::PrepareForPlaybackToCanvas(CdlCanvas* canvas) const {
   // TODO(hendrikw): See if we can split this up into separate functions.
 
   if (canvas->getClipStack()->quickContains(
-          SkRect::MakeFromIRect(canvas->imageInfo().bounds()))) {
+          SkRect::MakeFromIRect(GetSkCanvas(canvas)->imageInfo().bounds()))) {
     canvas->discard();
   }
 
   // If this raster source has opaque contents, it is guaranteeing that it will
   // draw an opaque rect the size of the layer.  If it is not, then we must
   // clear this canvas ourselves.
   if (requires_clear_) {
     canvas->clear(SK_ColorTRANSPARENT);
     return;
   }
@@ skipping 53 matching lines @@
   canvas->save();
   // Use clipRegion to bypass CTM because the rects are device rects.
   SkRegion interest_region;
   interest_region.setRect(interest_rect);
   interest_region.op(opaque_rect, SkRegion::kDifference_Op);
   canvas->clipRegion(interest_region);
   canvas->clear(background_color_);
   canvas->restore();
 }
 
-void RasterSource::RasterCommon(SkCanvas* canvas,
+void RasterSource::RasterCommon(CdlCanvas* canvas,
                                 SkPicture::AbortCallback* callback) const {
   DCHECK(display_list_.get());
   int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
   for (int i = 0; i < repeat_count; ++i)
     display_list_->Raster(canvas, callback);
 }
 
-sk_sp<SkPicture> RasterSource::GetFlattenedPicture() {
+sk_sp<CdlPicture> RasterSource::GetFlattenedPicture() {
   TRACE_EVENT0("cc", "RasterSource::GetFlattenedPicture");
 
-  SkPictureRecorder recorder;
-  SkCanvas* canvas = recorder.beginRecording(size_.width(), size_.height());
+  CdlPictureRecorder recorder;
+  CdlCanvas* canvas = recorder.beginRecording(size_.width(), size_.height());
   if (!size_.IsEmpty()) {
     PrepareForPlaybackToCanvas(canvas);
     RasterCommon(canvas, nullptr);
   }
 
   return recorder.finishRecordingAsPicture();
 }
 
 size_t RasterSource::GetPictureMemoryUsage() const {
   if (!display_list_)
     return 0;
   return display_list_->ApproximateMemoryUsage() +
          painter_reported_memory_usage_;
 }
 
 bool RasterSource::PerformSolidColorAnalysis(const gfx::Rect& content_rect,
                                              const gfx::SizeF& raster_scales,
                                              SkColor* color) const {
   TRACE_EVENT0("cc", "RasterSource::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.f / raster_scales.width(), 1.f / raster_scales.height());
 
   layer_rect.Intersect(gfx::Rect(size_));
-  skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
+  skia::AnalysisCanvas sk_canvas(layer_rect.width(), layer_rect.height());
+  CdlPassThroughCanvas canvas(&sk_canvas);
   canvas.translate(-layer_rect.x(), -layer_rect.y());
-  RasterCommon(&canvas, &canvas);
-  return canvas.GetColorIfSolid(color);
+  RasterCommon(&canvas, &sk_canvas);
+  return sk_canvas.GetColorIfSolid(color);
 }
 
 void RasterSource::GetDiscardableImagesInRect(
     const gfx::Rect& layer_rect,
     const gfx::SizeF& raster_scales,
     std::vector<DrawImage>* images) const {
   DCHECK_EQ(0u, images->size());
   display_list_->GetDiscardableImagesInRect(layer_rect, raster_scales, images);
 }
 
@@ skipping 60 matching lines @@
   bool can_use_lcd_text = false;
   return scoped_refptr<RasterSource>(new RasterSource(this, can_use_lcd_text));
 }
 
 RasterSource::PlaybackSettings::PlaybackSettings()
     : playback_to_shared_canvas(false),
       skip_images(false),
       use_image_hijack_canvas(true) {}
 
 }  // namespace cc