[NOT FOR COMMIT] Fully replace SkCanvas uses.

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
@@ skipping 43 matching lines @@
 #include "modules/canvas2d/HitRegion.h"
 #include "modules/canvas2d/Path2D.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiTextRun.h"
 #include "public/platform/Platform.h"
-#include "third_party/skia/include/core/SkCanvas.h"
+#include "skia/ext/cdl_canvas.h"
+#include "skia/ext/cdl_paint.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 
 namespace blink {
 
 static const char defaultFont[] = "10px sans-serif";
 static const char inherit[] = "inherit";
 static const char rtl[] = "rtl";
@@ skipping 10 matching lines @@
 // overdraw detection substitutes the recording canvas (to discard overdrawn
 // draw calls).
 class CanvasRenderingContext2DAutoRestoreSkCanvas {
   STACK_ALLOCATED();
 
  public:
   explicit CanvasRenderingContext2DAutoRestoreSkCanvas(
       CanvasRenderingContext2D* context)
       : m_context(context), m_saveCount(0) {
     ASSERT(m_context);
-    SkCanvas* c = m_context->drawingCanvas();
+    CdlCanvas* c = m_context->drawingCanvas();
     if (c) {
       m_saveCount = c->getSaveCount();
     }
   }
 
   ~CanvasRenderingContext2DAutoRestoreSkCanvas() {
-    SkCanvas* c = m_context->drawingCanvas();
+    CdlCanvas* c = m_context->drawingCanvas();
     if (c)
       c->restoreToCount(m_saveCount);
     m_context->validateStateStack();
   }
 
  private:
   Member<CanvasRenderingContext2D> m_context;
   int m_saveCount;
 };
 
@@ skipping 30 matching lines @@
 
 CanvasRenderingContext2D::~CanvasRenderingContext2D() {}
 
 void CanvasRenderingContext2D::dispose() {
   if (m_pruneLocalFontCacheScheduled)
     Platform::current()->currentThread()->removeTaskObserver(this);
 }
 
 void CanvasRenderingContext2D::validateStateStack() const {
 #if DCHECK_IS_ON()
-  if (SkCanvas* skCanvas = canvas()->existingDrawingCanvas()) {
+  if (CdlCanvas* skCanvas = canvas()->existingDrawingCanvas()) {
     // The canvas should always have an initial save frame, to support
     // resetting the top level matrix and clip.
     DCHECK_GT(skCanvas->getSaveCount(), 1);
 
     if (m_contextLostMode == NotLostContext) {
       DCHECK_EQ(static_cast<size_t>(skCanvas->getSaveCount()),
                 m_stateStack.size() + 1);
     }
   }
 #endif
@@ skipping 104 matching lines @@
     Event* event(Event::create(EventTypeNames::contextrestored));
     canvas()->dispatchEvent(event);
   }
 }
 
 void CanvasRenderingContext2D::reset() {
   // This is a multiple inherritance bootstrap
   BaseRenderingContext2D::reset();
 }
 
-void CanvasRenderingContext2D::restoreCanvasMatrixClipStack(SkCanvas* c) const {
+void CanvasRenderingContext2D::restoreCanvasMatrixClipStack(
+    CdlCanvas* c) const {
   restoreMatrixClipStack(c);
 }
 
 bool CanvasRenderingContext2D::shouldAntialias() const {
   return state().shouldAntialias();
 }
 
 void CanvasRenderingContext2D::setShouldAntialias(bool doAA) {
   modifiableState().setShouldAntialias(doAA);
 }
@@ skipping 71 matching lines @@
 
 void CanvasRenderingContext2D::snapshotStateForFilter() {
   // The style resolution required for fonts is not available in frame-less
   // documents.
   if (!canvas()->document().frame())
     return;
 
   modifiableState().setFontForFilter(accessFont());
 }
 
-SkCanvas* CanvasRenderingContext2D::drawingCanvas() const {
+CdlCanvas* CanvasRenderingContext2D::drawingCanvas() const {
   if (isContextLost())
     return nullptr;
   return canvas()->drawingCanvas();
 }
 
-SkCanvas* CanvasRenderingContext2D::existingDrawingCanvas() const {
+CdlCanvas* CanvasRenderingContext2D::existingDrawingCanvas() const {
   return canvas()->existingDrawingCanvas();
 }
 
 void CanvasRenderingContext2D::disableDeferral(DisableDeferralReason reason) {
   canvas()->disableDeferral(reason);
 }
 
 AffineTransform CanvasRenderingContext2D::baseTransform() const {
   return canvas()->baseTransform();
 }
@@ skipping 417 matching lines @@
   // The style resolution required for fonts is not available in frame-less
   // documents.
   if (!canvas()->document().frame())
     return;
 
   // accessFont needs the style to be up to date, but updating style can cause
   // script to run, (e.g. due to autofocus) which can free the canvas (set size
   // to 0, for example), so update style before grabbing the drawingCanvas.
   canvas()->document().updateStyleAndLayoutTreeForNode(canvas());
 
-  SkCanvas* c = drawingCanvas();
+  CdlCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(x) || !std::isfinite(y))
     return;
   if (maxWidth && (!std::isfinite(*maxWidth) || *maxWidth <= 0))
     return;
 
   // Currently, SkPictureImageFilter does not support subpixel text
   // anti-aliasing, which is expected when !creationAttributes().alpha(), so we
@@ skipping 62 matching lines @@
     drawingCanvas()->save();
     drawingCanvas()->translate(location.x(), location.y());
     // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op)
     // still work.
     drawingCanvas()->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);
     location = FloatPoint();
   }
 
   draw(
       [&font, this, &textRunPaintInfo, &location](
-          SkCanvas* c, const SkPaint* paint)  // draw lambda
+          CdlCanvas* c, const CdlPaint* paint)  // draw lambda
       {
+        (void)cDeviceScaleFactor;
         font.drawBidiText(c, textRunPaintInfo, location,
                           Font::UseFallbackIfFontNotReady, cDeviceScaleFactor,
                           *paint);
       },
       [](const SkIRect& rect)  // overdraw test lambda
       { return false; },
       textRunPaintInfo.bounds, paintType);
 }
 
 const Font& CanvasRenderingContext2D::accessFont() {
@@ skipping 156 matching lines @@
       !canvas()->isSupportedInteractiveCanvasFallback(*options.control())) {
     exceptionState.throwDOMException(NotSupportedError,
                                      "The control is neither null nor a "
                                      "supported interactive canvas fallback "
                                      "element.");
     return;
   }
 
   Path hitRegionPath = options.hasPath() ? options.path()->path() : m_path;
 
-  SkCanvas* c = drawingCanvas();
+  CdlCanvas* c = drawingCanvas();
 
   if (hitRegionPath.isEmpty() || !c || !state().isTransformInvertible() ||
       !c->getClipDeviceBounds(0)) {
     exceptionState.throwDOMException(NotSupportedError,
                                      "The specified path has no pixels.");
     return;
   }
 
   hitRegionPath.transform(state().transform());
 
@@ skipping 68 matching lines @@
   }
   return true;
 }
 
 void CanvasRenderingContext2D::resetUsageTracking() {
   UsageCounters newCounters;
   m_usageCounters = newCounters;
 }
 
 }  // namespace blink