[NOT FOR COMMIT] Fully replace SkCanvas uses.

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp

 // Copyright 2014 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 "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/Histogram.h"
 #include "platform/graphics/CanvasMetrics.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "skia/ext/cdl_picture_recorder.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 RecordingImageBufferSurface::RecordingImageBufferSurface(
     const IntSize& size,
     std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> fallbackFactory,
     OpacityMode opacityMode,
     sk_sp<SkColorSpace> colorSpace,
     SkColorType colorType)
     : ImageBufferSurface(size, opacityMode, std::move(colorSpace), colorType),
       m_imageBuffer(0),
       m_currentFramePixelCount(0),
       m_previousFramePixelCount(0),
       m_frameWasCleared(true),
       m_didRecordDrawCommandsInCurrentFrame(false),
       m_currentFrameHasExpensiveOp(false),
       m_previousFrameHasExpensiveOp(false),
       m_fallbackFactory(std::move(fallbackFactory)) {
   initializeCurrentFrame();
 }
 
 RecordingImageBufferSurface::~RecordingImageBufferSurface() {}
 
 void RecordingImageBufferSurface::initializeCurrentFrame() {
   static SkRTreeFactory rTreeFactory;
-  m_currentFrame = wrapUnique(new SkPictureRecorder);
-  SkCanvas* canvas = m_currentFrame->beginRecording(
+  m_currentFrame = wrapUnique(new CdlPictureRecorder);
+  CdlCanvas* canvas = m_currentFrame->beginRecording(
       size().width(), size().height(), &rTreeFactory);
   // Always save an initial frame, to support resetting the top level matrix
   // and clip.
   canvas->save();
 
   if (m_imageBuffer) {
     m_imageBuffer->resetCanvas(canvas);
   }
   m_didRecordDrawCommandsInCurrentFrame = false;
   m_currentFrameHasExpensiveOp = false;
@@ skipping 104 matching lines @@
 }
 
 sk_sp<SkImage> RecordingImageBufferSurface::newImageSnapshot(
     AccelerationHint hint,
     SnapshotReason reason) {
   if (!m_fallbackSurface)
     fallBackToRasterCanvas(snapshotReasonToFallbackReason(reason));
   return m_fallbackSurface->newImageSnapshot(hint, reason);
 }
 
-SkCanvas* RecordingImageBufferSurface::canvas() {
+CdlCanvas* RecordingImageBufferSurface::canvas() {
   if (m_fallbackSurface)
     return m_fallbackSurface->canvas();
 
   ASSERT(m_currentFrame->getRecordingCanvas());
   return m_currentFrame->getRecordingCanvas();
 }
 
 static RecordingImageBufferSurface::FallbackReason
 disableDeferralReasonToFallbackReason(DisableDeferralReason reason) {
   switch (reason) {
@@ skipping 22 matching lines @@
   ASSERT_NOT_REACHED();
   return RecordingImageBufferSurface::FallbackReasonUnknown;
 }
 
 void RecordingImageBufferSurface::disableDeferral(
     DisableDeferralReason reason) {
   if (!m_fallbackSurface)
     fallBackToRasterCanvas(disableDeferralReasonToFallbackReason(reason));
 }
 
-sk_sp<SkPicture> RecordingImageBufferSurface::getPicture() {
+sk_sp<CdlPicture> RecordingImageBufferSurface::getPicture() {
   if (m_fallbackSurface)
     return nullptr;
 
   FallbackReason fallbackReason = FallbackReasonUnknown;
   bool canUsePicture = finalizeFrameInternal(&fallbackReason);
   m_imageBuffer->didFinalizeFrame();
 
   ASSERT(canUsePicture || m_fallbackFactory);
 
   if (canUsePicture) {
@@ skipping 98 matching lines @@
 
 void RecordingImageBufferSurface::draw(GraphicsContext& context,
                                        const FloatRect& destRect,
                                        const FloatRect& srcRect,
                                        SkBlendMode op) {
   if (m_fallbackSurface) {
     m_fallbackSurface->draw(context, destRect, srcRect, op);
     return;
   }
 
-  sk_sp<SkPicture> picture = getPicture();
+  sk_sp<CdlPicture> picture = getPicture();
   if (picture) {
     context.compositePicture(std::move(picture), destRect, srcRect, op);
   } else {
     ImageBufferSurface::draw(context, destRect, srcRect, op);
   }
 }
 
 bool RecordingImageBufferSurface::isExpensiveToPaint() {
   if (m_fallbackSurface)
     return m_fallbackSurface->isExpensiveToPaint();
@@ skipping 45 matching lines @@
 }
 
 void RecordingImageBufferSurface::setIsHidden(bool hidden) {
   if (m_fallbackSurface)
     m_fallbackSurface->setIsHidden(hidden);
   else
     ImageBufferSurface::setIsHidden(hidden);
 }
 
 }  // namespace blink