[NOT FOR COMMIT] Fully replace SkCanvas uses.

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 54 matching lines @@
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/image-encoders/ImageEncoderUtils.h"
 #include "platform/transforms/AffineTransform.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
+#include "skia/ext/cdl_canvas.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include <math.h>
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
@@ skipping 281 matching lines @@
 
   m_context->incrementFrameCount();
 }
 
 void HTMLCanvasElement::didDisableAcceleration() {
   // We must force a paint invalidation on the canvas even if it's
   // content did not change because it layer was destroyed.
   didDraw(FloatRect(0, 0, size().width(), size().height()));
 }
 
-void HTMLCanvasElement::restoreCanvasMatrixClipStack(SkCanvas* canvas) const {
+void HTMLCanvasElement::restoreCanvasMatrixClipStack(CdlCanvas* canvas) const {
   if (m_context)
     m_context->restoreCanvasMatrixClipStack(canvas);
 }
 
 void HTMLCanvasElement::doDeferredPaintInvalidation() {
   DCHECK(!m_dirtyRect.isEmpty());
   if (!m_context->is2d()) {
     didFinalizeFrame();
   } else {
     DCHECK(hasImageBuffer());
@@ skipping 392 matching lines @@
 
   CheckedNumeric<int> checkedCanvasPixelCount = size.width();
   checkedCanvasPixelCount *= size.height();
   if (!checkedCanvasPixelCount.IsValid())
     return false;
   int canvasPixelCount = checkedCanvasPixelCount.ValueOrDie();
 
   if (RuntimeEnabledFeatures::displayList2dCanvasEnabled()) {
 #if 0
         // TODO(junov): re-enable this code once we solve the problem of recording
-        // GPU-backed images to an SkPicture for cross-context rendering crbug.com/490328
+        // GPU-backed images to an CdlPicture for cross-context rendering crbug.com/490328
 
         // If the compositor provides GPU acceleration to display list canvases, we
         // prefer that over direct acceleration.
         if (document().viewportDescription().matchesHeuristicsForGpuRasterization())
             return false;
 #endif
     // If the GPU resources would be very expensive, prefer a display list.
     if (canvasPixelCount > ExpensiveCanvasHeuristicParameters::
                                PreferDisplayListOverGpuSizeThreshold)
       return false;
@@ skipping 245 matching lines @@
       checkedExternallyAllocatedMemory.ValueOrDefault(
           std::numeric_limits<intptr_t>::max());
 
   // Subtracting two intptr_t that are known to be positive will never
   // underflow.
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       externallyAllocatedMemory - m_externallyAllocatedMemory);
   m_externallyAllocatedMemory = externallyAllocatedMemory;
 }
 
-SkCanvas* HTMLCanvasElement::drawingCanvas() const {
+CdlCanvas* HTMLCanvasElement::drawingCanvas() const {
   return buffer() ? m_imageBuffer->canvas() : nullptr;
 }
 
 void HTMLCanvasElement::disableDeferral(DisableDeferralReason reason) const {
   if (buffer())
     m_imageBuffer->disableDeferral(reason);
 }
 
-SkCanvas* HTMLCanvasElement::existingDrawingCanvas() const {
+CdlCanvas* HTMLCanvasElement::existingDrawingCanvas() const {
   if (!hasImageBuffer())
     return nullptr;
 
   return m_imageBuffer->canvas();
 }
 
 ImageBuffer* HTMLCanvasElement::buffer() const {
   DCHECK(m_context);
   DCHECK(m_context->getContextType() !=
          CanvasRenderingContext::ContextImageBitmap);
@@ skipping 294 matching lines @@
   mojom::blink::OffscreenCanvasSurfacePtr service;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&service));
   m_surfaceLayerBridge =
       wrapUnique(new CanvasSurfaceLayerBridge(std::move(service)));
   return m_surfaceLayerBridge->createSurfaceLayer(this->width(),
                                                   this->height());
 }
 
 }  // namespace blink