Rename paint data structures

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 22 matching lines @@
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/geometry/Region.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/CompositorFilterOperations.h"
 #include "platform/graphics/FirstPaintInvalidationTracking.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/LinkHighlight.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
+#include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/graphics/paint/RasterInvalidationTracking.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/json/JSONValues.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/text/TextStream.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
@@ skipping 238 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<PaintRecord> newPicture = capturePicture();
       checkPaintUnderInvalidations(*newPicture);
       RasterInvalidationTracking& tracking =
           rasterInvalidationTrackingMap().add(this);
       tracking.lastPaintedPicture = std::move(newPicture);
       tracking.lastInterestRect = m_previousInterestRect;
       tracking.rasterInvalidationRegionSinceLastPaint = Region();
     }
   }
 }
 
@@ skipping 891 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<PaintRecord> GraphicsLayer::capturePicture() {
   if (!drawsContent())
     return nullptr;
 
   IntSize intSize = expandedIntSize(size());
   GraphicsContext graphicsContext(getPaintController(),
                                   GraphicsContext::NothingDisabled, nullptr,
                                   m_colorBehavior);
   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 PaintRecord& 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 bitmapCanvas(oldBitmap);
+    PaintCanvasPassThrough canvas(&bitmapCanvas);
     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 bitmapCanvas(newBitmap);
+    PaintCanvasPassThrough canvas(&bitmapCanvas);
     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;
+  PaintRecorder recorder;
   recorder.beginRecording(rect);
   recorder.getRecordingCanvas()->drawBitmap(newBitmap, rect.x(), rect.y());
-  sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
+  sk_sp<PaintRecord> 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