[NOT FOR COMMIT] Fully replace SkCanvas uses.

content/renderer/pepper/pepper_graphics_2d_host.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/pepper_graphics_2d_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 258 matching lines @@
   SkIRect src_irect = {x, y, x + image_resource->width(),
                        y + image_resource->height()};
   SkRect dest_rect = {SkIntToScalar(0), SkIntToScalar(0),
                       SkIntToScalar(image_resource->width()),
                       SkIntToScalar(image_resource->height())};
 
   if (image_resource->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
     ConvertImageData(image_data_.get(), src_irect, image_resource, dest_rect);
   } else {
-    SkCanvas* dest_canvas = image_resource->GetCanvas();
+    CdlCanvas* dest_canvas = image_resource->GetCanvas();
 
     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setBlendMode(SkBlendMode::kSrc);
-    dest_canvas->drawBitmapRect(
-        image_data_->GetMappedBitmap(), src_irect, dest_rect, &paint);
+    GetSkCanvas(dest_canvas)
+        ->drawBitmapRect(image_data_->GetMappedBitmap(), src_irect, dest_rect,
+                         &paint);
   }
   return true;
 }
 
 bool PepperGraphics2DHost::BindToInstance(
     PepperPluginInstanceImpl* new_instance) {
   if (new_instance && new_instance->pp_instance() != pp_instance())
     return false;  // Can't bind other instance's contexts.
   if (bound_instance_ == new_instance)
     return true;  // Rebinding the same device, nothing to do.
@@ skipping 24 matching lines @@
 void PepperGraphics2DHost::Paint(blink::WebCanvas* canvas,
                                  const gfx::Rect& plugin_rect,
                                  const gfx::Rect& paint_rect) {
   TRACE_EVENT0("pepper", "PepperGraphics2DHost::Paint");
   ImageDataAutoMapper auto_mapper(image_data_.get());
   SkBitmap backing_bitmap = image_data_->GetMappedBitmap();
 
   gfx::Rect invalidate_rect = plugin_rect;
   invalidate_rect.Intersect(paint_rect);
   SkRect sk_invalidate_rect = gfx::RectToSkRect(invalidate_rect);
-  SkAutoCanvasRestore auto_restore(canvas, true);
+  CdlAutoCanvasRestore auto_restore(canvas, true);
   canvas->clipRect(sk_invalidate_rect);
   gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
   gfx::Size image_size = gfx::ScaleToFlooredSize(pixel_image_size, scale_);
 
   PepperPluginInstance* plugin_instance =
       renderer_ppapi_host_->GetPluginInstance(pp_instance());
   if (!plugin_instance)
     return;
   if (plugin_instance->IsFullPagePlugin()) {
     // When we're resizing a window with a full-frame plugin, the plugin may
     // not yet have bound a new device, which will leave parts of the
     // background exposed if the window is getting larger. We want this to
     // show white (typically less jarring) rather than black or uninitialized.
     // We don't do this for non-full-frame plugins since we specifically want
     // the page background to show through.
-    SkAutoCanvasRestore auto_restore(canvas, true);
+    CdlAutoCanvasRestore auto_restore(canvas, true);
     SkRect image_data_rect =
         gfx::RectToSkRect(gfx::Rect(plugin_rect.origin(), image_size));
     canvas->clipRect(image_data_rect, SkRegion::kDifference_Op);
 
-    SkPaint paint;
+    CdlPaint paint;
     paint.setBlendMode(SkBlendMode::kSrc);
     paint.setColor(SK_ColorWHITE);
     canvas->drawRect(sk_invalidate_rect, paint);
   }
 
-  SkPaint paint;
+  CdlPaint paint;
   if (is_always_opaque_) {
     // When we know the device is opaque, we can disable blending for slightly
     // more optimized painting.
     paint.setBlendMode(SkBlendMode::kSrc);
   }
 
   SkPoint pixel_origin(PointToSkPoint(plugin_rect.origin()));
   if (scale_ != 1.0f && scale_ > 0.0f) {
     canvas->scale(scale_, scale_);
     pixel_origin.scale(1.0f / scale_);
@@ skipping 360 matching lines @@
   SkRect dest_rect = {SkIntToScalar(invalidated_rect->x()),
                       SkIntToScalar(invalidated_rect->y()),
                       SkIntToScalar(invalidated_rect->right()),
                       SkIntToScalar(invalidated_rect->bottom())};
 
   if (image->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
     ConvertImageData(image, src_irect, image_data_.get(), dest_rect);
   } else {
     // We're guaranteed to have a mapped canvas since we mapped it in Init().
-    SkCanvas* backing_canvas = image_data_->GetCanvas();
+    CdlCanvas* backing_canvas = image_data_->GetCanvas();
 
     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setBlendMode(SkBlendMode::kSrc);
-    backing_canvas->drawBitmapRect(
-        image->GetMappedBitmap(), src_irect, dest_rect, &paint);
+    GetSkCanvas(backing_canvas)
+        ->drawBitmapRect(image->GetMappedBitmap(), src_irect, dest_rect,
+                         &paint);
   }
 }
 
 void PepperGraphics2DHost::ExecuteScroll(const gfx::Rect& clip,
                                          int dx,
                                          int dy,
                                          gfx::Rect* invalidated_rect) {
   gfx::ScrollCanvas(image_data_->GetCanvas(), clip, gfx::Vector2d(dx, dy));
   *invalidated_rect = clip;
 }
@@ skipping 74 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ScaleToFlooredPoint(*delta, inverse_scale);
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content