[NOT FOR COMMIT] Fully replace SkCanvas uses.

media/renderers/skcanvas_video_renderer.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 "media/renderers/skcanvas_video_renderer.h"
 
 #include <limits>
 
 #include "base/macros.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "skia/ext/texture_handle.h"
+#include "skia/ext/cdl_canvas.h"
+#include "skia/ext/cdl_paint.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrPaint.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "third_party/skia/include/gpu/SkGr.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
@@ skipping 298 matching lines @@
           FROM_HERE,
           base::TimeDelta::FromSeconds(kTemporaryResourceDeletionDelay),
           this,
           &SkCanvasVideoRenderer::ResetCache) {}
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {
   ResetCache();
 }
 
 void SkCanvasVideoRenderer::Paint(const scoped_refptr<VideoFrame>& video_frame,
-                                  SkCanvas* canvas,
+                                  CdlCanvas* canvas,
                                   const gfx::RectF& dest_rect,
-                                  SkPaint& paint,
+                                  CdlPaint& paint,
                                   VideoRotation video_rotation,
                                   const Context3D& context_3d) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (paint.getAlpha() == 0) {
     return;
   }
 
   SkRect dest;
   dest.set(dest_rect.x(), dest_rect.y(), dest_rect.right(), dest_rect.bottom());
 
   // Paint black rectangle if there isn't a frame available or the
   // frame has an unexpected format.
   if (!video_frame.get() || video_frame->natural_size().IsEmpty() ||
       !(media::IsYuvPlanar(video_frame->format()) ||
         video_frame->format() == media::PIXEL_FORMAT_Y16 ||
         video_frame->HasTextures())) {
-    SkPaint blackWithAlphaPaint;
+    CdlPaint blackWithAlphaPaint;
     blackWithAlphaPaint.setAlpha(paint.getAlpha());
     canvas->drawRect(dest, blackWithAlphaPaint);
     canvas->flush();
     return;
   }
 
   gpu::gles2::GLES2Interface* gl = context_3d.gl;
   if (!UpdateLastImage(video_frame, context_3d))
     return;
 
-  SkPaint videoPaint;
+  CdlPaint videoPaint;
   videoPaint.setAlpha(paint.getAlpha());
   videoPaint.setBlendMode(paint.getBlendMode());
   videoPaint.setFilterQuality(paint.getFilterQuality());
 
   const bool need_rotation = video_rotation != VIDEO_ROTATION_0;
   const bool need_scaling =
       dest_rect.size() !=
       gfx::SizeF(gfx::SkISizeToSize(last_image_->dimensions()));
   const bool need_translation = !dest_rect.origin().IsOrigin();
   bool need_transform = need_rotation || need_scaling || need_translation;
@@ skipping 30 matching lines @@
     canvas->translate(-SkFloatToScalar(last_image_->width() * 0.5f),
                       -SkFloatToScalar(last_image_->height() * 0.5f));
   }
 
   // This is a workaround for crbug.com/524717. A texture backed image is not
   // safe to access on another thread or GL context. So if we're drawing into a
   // recording canvas we read the texture back into CPU memory and record that
   // sw image into the SkPicture. The long term solution is for Skia to provide
   // a SkPicture filter that makes a picture safe for multiple CPU raster
   // threads. (skbug.com/4321).
-  if (canvas->imageInfo().colorType() == kUnknown_SkColorType) {
+  if (GetSkCanvas(canvas)->imageInfo().colorType() == kUnknown_SkColorType) {
     sk_sp<SkImage> swImage = last_image_->makeNonTextureImage();
+
     canvas->drawImage(swImage, 0, 0, &videoPaint);
   } else {
     canvas->drawImage(last_image_.get(), 0, 0, &videoPaint);
   }
 
   if (need_transform)
     canvas->restore();
   // Make sure to flush so we can remove the videoframe from the generator.
   canvas->flush();
 
   if (video_frame->HasTextures()) {
     DCHECK(gl);
     SyncTokenClientImpl client(gl);
     video_frame->UpdateReleaseSyncToken(&client);
   }
 }
 
 void SkCanvasVideoRenderer::Copy(const scoped_refptr<VideoFrame>& video_frame,
-                                 SkCanvas* canvas,
+                                 CdlCanvas* canvas,
                                  const Context3D& context_3d) {
-  SkPaint paint;
+  CdlPaint paint;
   paint.setBlendMode(SkBlendMode::kSrc);
   paint.setFilterQuality(kLow_SkFilterQuality);
   Paint(video_frame, canvas, gfx::RectF(video_frame->visible_rect()), paint,
         media::VIDEO_ROTATION_0, context_3d);
 }
 
 namespace {
 
 // libyuv doesn't support 9- and 10-bit video frames yet. This function
 // creates a regular 8-bit video frame which we can give to libyuv.
@@ skipping 393 matching lines @@
       last_image_->bounds().contains(visible_rect)) {
     last_image_ = last_image_->makeSubset(visible_rect);
   }
 }
 
 SkISize SkCanvasVideoRenderer::LastImageDimensionsForTesting() {
   return last_image_dimensions_for_testing_;
 }
 
 }  // namespace media