[NOT FOR COMMIT] Fully replace SkCanvas uses.

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

 /*
  * Copyright (C) 2009 Apple Inc. 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 35 matching lines @@
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/text/TextStream.h"
 #include "platform/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebSize.h"
+#include "skia/ext/cdl_canvas.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #include <cmath>
 #include <memory>
@@ skipping 219 matching lines @@
 IntRect GraphicsLayer::interestRect() {
   return m_previousInterestRect;
 }
 
 void GraphicsLayer::paint(const IntRect* interestRect,
                           GraphicsContext::DisabledMode disabledMode) {
   if (paintWithoutCommit(interestRect, disabledMode)) {
     getPaintController().commitNewDisplayItems(
         offsetFromLayoutObjectWithSubpixelAccumulation());
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
-      sk_sp<SkPicture> newPicture = capturePicture();
+      sk_sp<CdlPicture> newPicture = capturePicture();
       checkPaintUnderInvalidations(*newPicture);
       RasterInvalidationTracking& tracking =
           rasterInvalidationTrackingMap().add(this);
       tracking.lastPaintedPicture = std::move(newPicture);
       tracking.lastInterestRect = m_previousInterestRect;
       tracking.rasterInvalidationRegionSinceLastPaint = Region();
     }
   }
 }
 
@@ skipping 892 matching lines @@
   if (WebLayer* layer = platformLayer())
     return layer->elementId();
   return CompositorElementId();
 }
 
 void GraphicsLayer::setCompositorMutableProperties(uint32_t properties) {
   if (WebLayer* layer = platformLayer())
     layer->setCompositorMutableProperties(properties);
 }
 
-sk_sp<SkPicture> GraphicsLayer::capturePicture() {
+sk_sp<CdlPicture> GraphicsLayer::capturePicture() {
   if (!drawsContent())
     return nullptr;
 
   IntSize intSize = expandedIntSize(size());
   GraphicsContext graphicsContext(getPaintController());
   graphicsContext.beginRecording(IntRect(IntPoint(0, 0), intSize));
   getPaintController().paintArtifact().replay(graphicsContext);
   return graphicsContext.endRecording();
 }
 
 static bool pixelComponentsDiffer(int c1, int c2) {
   // Compare strictly for saturated values.
   if (c1 == 0 || c1 == 255 || c2 == 0 || c2 == 255)
     return c1 != c2;
   // Tolerate invisible differences that may occur in gradients etc.
   return abs(c1 - c2) > 2;
 }
 
 static bool pixelsDiffer(SkColor p1, SkColor p2) {
   return pixelComponentsDiffer(SkColorGetA(p1), SkColorGetA(p2)) ||
          pixelComponentsDiffer(SkColorGetR(p1), SkColorGetR(p2)) ||
          pixelComponentsDiffer(SkColorGetG(p1), SkColorGetG(p2)) ||
          pixelComponentsDiffer(SkColorGetB(p1), SkColorGetB(p2));
 }
 
-void GraphicsLayer::checkPaintUnderInvalidations(const SkPicture& newPicture) {
+void GraphicsLayer::checkPaintUnderInvalidations(const CdlPicture& newPicture) {
   if (!drawsContent())
     return;
 
   RasterInvalidationTracking* tracking =
       rasterInvalidationTrackingMap().find(this);
   if (!tracking)
     return;
 
   if (!tracking->lastPaintedPicture)
     return;
 
   IntRect rect = intersection(tracking->lastInterestRect, interestRect());
   if (rect.isEmpty())
     return;
 
   SkBitmap oldBitmap;
   oldBitmap.allocPixels(
       SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
   {
-    SkCanvas canvas(oldBitmap);
+    SkCanvas sk_canvas(oldBitmap);
+    CdlPassThroughCanvas canvas(&sk_canvas);
     canvas.clear(SK_ColorTRANSPARENT);
     canvas.translate(-rect.x(), -rect.y());
     canvas.drawPicture(tracking->lastPaintedPicture.get());
   }
 
   SkBitmap newBitmap;
   newBitmap.allocPixels(
       SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
   {
-    SkCanvas canvas(newBitmap);
+    SkCanvas sk_canvas(newBitmap);
+    CdlPassThroughCanvas canvas(&sk_canvas);
     canvas.clear(SK_ColorTRANSPARENT);
     canvas.translate(-rect.x(), -rect.y());
     canvas.drawPicture(&newPicture);
   }
 
   oldBitmap.lockPixels();
   newBitmap.lockPixels();
   int mismatchingPixels = 0;
   static const int maxMismatchesToReport = 50;
   for (int bitmapY = 0; bitmapY < rect.height(); ++bitmapY) {
@@ skipping 23 matching lines @@
         *newBitmap.getAddr32(bitmapX, bitmapY) = SK_ColorTRANSPARENT;
       }
     }
   }
   oldBitmap.unlockPixels();
   newBitmap.unlockPixels();
 
   // Visualize under-invalidations by overlaying the new bitmap (containing red
   // pixels indicating under-invalidations, and transparent pixels otherwise)
   // onto the painting.
-  SkPictureRecorder recorder;
+  CdlPictureRecorder recorder;
   recorder.beginRecording(rect);
   recorder.getRecordingCanvas()->drawBitmap(newBitmap, rect.x(), rect.y());
-  sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
+  sk_sp<CdlPicture> picture = recorder.finishRecordingAsPicture();
   getPaintController().appendDebugDrawingAfterCommit(
       *this, picture, offsetFromLayoutObjectWithSubpixelAccumulation());
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     LOG(INFO) << "Cannot showGraphicsLayerTree for (nil).";
     return;
   }
 
   String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
   LOG(INFO) << output.utf8().data();
 }
 #endif