[NOT FOR COMMIT] Fully replace SkCanvas uses.

content/renderer/pepper/ppb_image_data_impl.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/ppb_image_data_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 
 #include "base/logging.h"
 #include "content/common/pepper_file_util.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/thunk/thunk.h"
+#include "skia/ext/cdl_canvas.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPixmap.h"
 #include "ui/surface/transport_dib.h"
 
 using ppapi::thunk::PPB_ImageData_API;
 
 namespace content {
@@ skipping 76 matching lines @@
 
 void* PPB_ImageData_Impl::Map() { return backend_->Map(); }
 
 void PPB_ImageData_Impl::Unmap() { backend_->Unmap(); }
 
 int32_t PPB_ImageData_Impl::GetSharedMemory(base::SharedMemory** shm,
                                             uint32_t* byte_count) {
   return backend_->GetSharedMemory(shm, byte_count);
 }
 
-SkCanvas* PPB_ImageData_Impl::GetPlatformCanvas() {
+CdlCanvas* PPB_ImageData_Impl::GetPlatformCanvas() {
   return backend_->GetPlatformCanvas();
 }
 
-SkCanvas* PPB_ImageData_Impl::GetCanvas() { return backend_->GetCanvas(); }
+CdlCanvas* PPB_ImageData_Impl::GetCanvas() {
+  return backend_->GetCanvas();
+}
 
 void PPB_ImageData_Impl::SetIsCandidateForReuse() {
   // Nothing to do since we don't support image data re-use in-process.
 }
 
 SkBitmap PPB_ImageData_Impl::GetMappedBitmap() const {
   return backend_->GetMappedBitmap();
 }
 
 // ImageDataPlatformBackend ----------------------------------------------------
@@ skipping 60 matching lines @@
   // in the future to save some memory.
 }
 
 int32_t ImageDataPlatformBackend::GetSharedMemory(base::SharedMemory** shm,
                                                   uint32_t* byte_count) {
   *byte_count = dib_->size();
   *shm = dib_->shared_memory();
   return PP_OK;
 }
 
-SkCanvas* ImageDataPlatformBackend::GetPlatformCanvas() {
+CdlCanvas* ImageDataPlatformBackend::GetPlatformCanvas() {
   return mapped_canvas_.get();
 }
 
-SkCanvas* ImageDataPlatformBackend::GetCanvas() { return mapped_canvas_.get(); }
+CdlCanvas* ImageDataPlatformBackend::GetCanvas() {
+  return mapped_canvas_.get();
+}
 
 SkBitmap ImageDataPlatformBackend::GetMappedBitmap() const {
   SkBitmap bitmap;
   if (!mapped_canvas_)
     return bitmap;
 
   SkPixmap pixmap;
   skia::GetWritablePixels(mapped_canvas_.get(), &pixmap);
   // SkPixmap does not manage the lifetime of this pointer, so it remains
   // valid after the object goes out of scope. It will become invalid if
@@ skipping 26 matching lines @@
 
 TransportDIB* ImageDataSimpleBackend::GetTransportDIB() const { return NULL; }
 
 void* ImageDataSimpleBackend::Map() {
   DCHECK(shared_memory_.get());
   if (map_count_++ == 0) {
     shared_memory_->Map(skia_bitmap_.getSize());
     skia_bitmap_.setPixels(shared_memory_->memory());
     // Our platform bitmaps are set to opaque by default, which we don't want.
     skia_bitmap_.setAlphaType(kPremul_SkAlphaType);
-    skia_canvas_ = base::MakeUnique<SkCanvas>(skia_bitmap_);
+    skia_canvas_ = base::MakeUnique<CdlCanvas>(skia_bitmap_);
     return skia_bitmap_.getAddr32(0, 0);
   }
   return shared_memory_->memory();
 }
 
 void ImageDataSimpleBackend::Unmap() {
   if (--map_count_ == 0)
     shared_memory_->Unmap();
 }
 
 int32_t ImageDataSimpleBackend::GetSharedMemory(base::SharedMemory** shm,
                                                 uint32_t* byte_count) {
   *byte_count = skia_bitmap_.getSize();
   *shm = shared_memory_.get();
   return PP_OK;
 }
 
-SkCanvas* ImageDataSimpleBackend::GetPlatformCanvas() {
+CdlCanvas* ImageDataSimpleBackend::GetPlatformCanvas() {
   return NULL;
 }
 
-SkCanvas* ImageDataSimpleBackend::GetCanvas() {
+CdlCanvas* ImageDataSimpleBackend::GetCanvas() {
   if (!IsMapped())
     return NULL;
   return skia_canvas_.get();
 }
 
 SkBitmap ImageDataSimpleBackend::GetMappedBitmap() const {
   if (!IsMapped())
     return SkBitmap();
   return skia_bitmap_;
 }
 
 }  // namespace content