SPv2: Add support for tracking raster paint invalidations in testing.

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 24 matching lines @@
 #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/PaintController.h"
+#include "platform/graphics/paint/RasterInvalidationTracking.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"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebSize.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>
 #include <utility>
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
-struct PaintInvalidationInfo {
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-    // This is for comparison only. Don't dereference because the client may have died.
-    const DisplayItemClient* client;
-    String clientDebugName;
-    IntRect rect;
-    PaintInvalidationReason reason;
-};
-
-struct UnderPaintInvalidation {
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-    int x;
-    int y;
-    SkColor oldPixel;
-    SkColor newPixel;
-};
-
-struct PaintInvalidationTracking {
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-    Vector<PaintInvalidationInfo> trackedPaintInvalidations;
-    sk_sp<SkPicture> lastPaintedPicture;
-    IntRect lastInterestRect;
-    Region paintInvalidationRegionSinceLastPaint;
-    Vector<UnderPaintInvalidation> underPaintInvalidations;
-};
-
-typedef HashMap<const GraphicsLayer*, PaintInvalidationTracking> PaintInvalidationTrackingMap;
-static PaintInvalidationTrackingMap& paintInvalidationTrackingMap()
+template class RasterInvalidationTrackingMap<const GraphicsLayer>;
+static RasterInvalidationTrackingMap<const GraphicsLayer>& rasterInvalidationTrackingMap()
 {
-    DEFINE_STATIC_LOCAL(PaintInvalidationTrackingMap, map, ());
+    DEFINE_STATIC_LOCAL(RasterInvalidationTrackingMap<const GraphicsLayer>, map, ());
     return map;
 }
 
 std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerClient* client)
 {
     return wrapUnique(new GraphicsLayer(client));
 }
 
 GraphicsLayer::GraphicsLayer(GraphicsLayerClient* client)
     : m_client(client)
     , m_backgroundColor(Color::transparent)
     , m_opacity(1)
     , m_blendMode(WebBlendModeNormal)
     , m_hasTransformOrigin(false)
     , m_contentsOpaque(false)
     , m_shouldFlattenTransform(true)
     , m_backfaceVisibility(true)
     , m_drawsContent(false)
     , m_contentsVisible(true)
     , m_isRootForIsolatedGroup(false)
     , m_hasScrollParent(false)
     , m_hasClipParent(false)
     , m_painted(false)
-    , m_isTrackingPaintInvalidations(client && client->isTrackingPaintInvalidations())
+    , m_isTrackingRasterInvalidations(client && client->isTrackingRasterInvalidations())
     , m_paintingPhase(GraphicsLayerPaintAllWithOverflowClip)
     , m_parent(0)
     , m_maskLayer(0)
     , m_contentsClippingMaskLayer(0)
     , m_paintCount(0)
     , m_contentsLayer(0)
     , m_contentsLayerId(0)
     , m_scrollableArea(nullptr)
     , m_renderingContext3d(0)
 {
@@ skipping 15 matching lines @@
     m_linkHighlights.clear();
 
 #if ENABLE(ASSERT)
     if (m_client)
         m_client->verifyNotPainting();
 #endif
 
     removeAllChildren();
     removeFromParent();
 
-    paintInvalidationTrackingMap().remove(this);
+    rasterInvalidationTrackingMap().remove(this);
     ASSERT(!m_parent);
 }
 
 LayoutRect GraphicsLayer::visualRect() const
 {
     LayoutRect bounds = LayoutRect(FloatPoint(), size());
     bounds.move(offsetFromLayoutObjectWithSubpixelAccumulation());
     return bounds;
 }
 
@@ skipping 129 matching lines @@
     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();
             checkPaintUnderInvalidations(*newPicture);
-            PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
+            RasterInvalidationTracking& tracking = rasterInvalidationTrackingMap().add(this);
             tracking.lastPaintedPicture = std::move(newPicture);
             tracking.lastInterestRect = m_previousInterestRect;
-            tracking.paintInvalidationRegionSinceLastPaint = Region();
+            tracking.rasterInvalidationRegionSinceLastPaint = Region();
         }
     }
 }
 
 bool GraphicsLayer::paintWithoutCommit(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
     ASSERT(drawsContent());
 
     if (!m_client)
         return false;
@@ skipping 178 matching lines @@
 {
     return m_debugInfo;
 }
 
 WebLayer* GraphicsLayer::contentsLayerIfRegistered()
 {
     clearContentsLayerIfUnregistered();
     return m_contentsLayer;
 }
 
-void GraphicsLayer::setTracksPaintInvalidations(bool tracksPaintInvalidations)
+void GraphicsLayer::setTracksRasterInvalidations(bool tracksRasterInvalidations)
 {
-    resetTrackedPaintInvalidations();
-    m_isTrackingPaintInvalidations = tracksPaintInvalidations;
+    resetTrackedRasterInvalidations();
+    m_isTrackingRasterInvalidations = tracksRasterInvalidations;
 }
 
-void GraphicsLayer::resetTrackedPaintInvalidations()
+void GraphicsLayer::resetTrackedRasterInvalidations()
 {
-    auto it = paintInvalidationTrackingMap().find(this);
-    if (it == paintInvalidationTrackingMap().end())
+    RasterInvalidationTracking* tracking = rasterInvalidationTrackingMap().find(this);
+    if (!tracking)
         return;
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
-        it->value.trackedPaintInvalidations.clear();
+        tracking->trackedRasterInvalidations.clear();
     else
-        paintInvalidationTrackingMap().remove(it);
+        rasterInvalidationTrackingMap().remove(this);
 }
 
-bool GraphicsLayer::hasTrackedPaintInvalidations() const
+bool GraphicsLayer::hasTrackedRasterInvalidations() const
 {
-    PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
-    if (it != paintInvalidationTrackingMap().end())
-        return !it->value.trackedPaintInvalidations.isEmpty();
+    RasterInvalidationTracking* tracking = rasterInvalidationTrackingMap().find(this);
+    if (tracking)
+        return !tracking->trackedRasterInvalidations.isEmpty();
     return false;
 }
 
-void GraphicsLayer::trackPaintInvalidation(const DisplayItemClient& client, const IntRect& rect, PaintInvalidationReason reason)
+void GraphicsLayer::trackRasterInvalidation(const DisplayItemClient& client, const IntRect& rect, PaintInvalidationReason reason)
 {
-    if (!isTrackingOrCheckingPaintInvalidations() || rect.isEmpty())
+    if (!isTrackingOrCheckingRasterInvalidations() || rect.isEmpty())
         return;
 
-    PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
+    RasterInvalidationTracking& tracking = rasterInvalidationTrackingMap().add(this);
 
-    if (m_isTrackingPaintInvalidations) {
-        PaintInvalidationInfo info = { &client, client.debugName(), rect, reason };
-        tracking.trackedPaintInvalidations.append(info);
+    if (m_isTrackingRasterInvalidations) {
+        RasterInvalidationInfo info;
+        info.client = &client;
+        info.clientDebugName = client.debugName();
+        info.rect = rect;
+        info.reason = reason;
+        tracking.trackedRasterInvalidations.append(info);
     }
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
         // TODO(crbug.com/496260): Some antialiasing effects overflows the paint invalidation rect.
         IntRect r = rect;
         r.inflate(1);
-        tracking.paintInvalidationRegionSinceLastPaint.unite(r);
+        tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
     }
 }
 
-static bool comparePaintInvalidationInfo(const PaintInvalidationInfo& a, const PaintInvalidationInfo& b)
-{
-    // Sort by rect first, bigger rects before smaller ones.
-    if (a.rect.width() != b.rect.width())
-        return a.rect.width() > b.rect.width();
-    if (a.rect.height() != b.rect.height())
-        return a.rect.height() > b.rect.height();
-    if (a.rect.x() != b.rect.x())
-        return a.rect.x() > b.rect.x();
-    if (a.rect.y() != b.rect.y())
-        return a.rect.y() > b.rect.y();
-
-    // Then compare clientDebugName, in alphabetic order.
-    int nameCompareResult = codePointCompare(a.clientDebugName, b.clientDebugName);
-    if (nameCompareResult != 0)
-        return nameCompareResult < 0;
-
-    return a.reason < b.reason;
-}
-
 template <typename T>
 static std::unique_ptr<JSONArray> pointAsJSONArray(const T& point)
 {
     std::unique_ptr<JSONArray> array = JSONArray::create();
     array->pushDouble(point.x());
     array->pushDouble(point.y());
     return array;
 }
 
 template <typename T>
 static std::unique_ptr<JSONArray> sizeAsJSONArray(const T& size)
 {
     std::unique_ptr<JSONArray> array = JSONArray::create();
     array->pushDouble(size.width());
     array->pushDouble(size.height());
     return array;
 }
 
-template <typename T>
-static std::unique_ptr<JSONArray> rectAsJSONArray(const T& rect)
-{
-    std::unique_ptr<JSONArray> array = JSONArray::create();
-    array->pushDouble(rect.x());
-    array->pushDouble(rect.y());
-    array->pushDouble(rect.width());
-    array->pushDouble(rect.height());
-    return array;
-}
-
 static double roundCloseToZero(double number)
 {
     return std::abs(number) < 1e-7 ? 0 : number;
 }
 
 static std::unique_ptr<JSONArray> transformAsJSONArray(const TransformationMatrix& t)
 {
     std::unique_ptr<JSONArray> array = JSONArray::create();
     {
         std::unique_ptr<JSONArray> row = JSONArray::create();
@@ skipping 98 matching lines @@
 
     if (flags & LayerTreeIncludesDebugInfo)
         json->setString("client", pointerAsString(m_client));
 
     if (m_backgroundColor.alpha())
         json->setString("backgroundColor", m_backgroundColor.nameForLayoutTreeAsText());
 
     if (!m_transform.isIdentity())
         json->setArray("transform", transformAsJSONArray(m_transform));
 
-    PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
-    if (it != paintInvalidationTrackingMap().end()) {
-        if (flags & LayerTreeIncludesPaintInvalidations) {
-            Vector<PaintInvalidationInfo>& infos = it->value.trackedPaintInvalidations;
-            if (!infos.isEmpty()) {
-                std::sort(infos.begin(), infos.end(), &comparePaintInvalidationInfo);
-                std::unique_ptr<JSONArray> paintInvalidationsJSON = JSONArray::create();
-                for (auto& info : infos) {
-                    std::unique_ptr<JSONObject> infoJSON = JSONObject::create();
-                    infoJSON->setString("object", info.clientDebugName);
-                    if (!info.rect.isEmpty())
-                        infoJSON->setArray("rect", rectAsJSONArray(info.rect));
-                    infoJSON->setString("reason", paintInvalidationReasonToString(info.reason));
-                    paintInvalidationsJSON->pushObject(std::move(infoJSON));
-                }
-                json->setArray("paintInvalidations", std::move(paintInvalidationsJSON));
-            }
-
-            Vector<UnderPaintInvalidation>& underPaintInvalidations = it->value.underPaintInvalidations;
-            if (!underPaintInvalidations.isEmpty()) {
-                std::unique_ptr<JSONArray> underPaintInvalidationsJSON = JSONArray::create();
-                for (auto& underPaintInvalidation : underPaintInvalidations) {
-                    std::unique_ptr<JSONObject> underPaintInvalidationJSON = JSONObject::create();
-                    underPaintInvalidationJSON->setDouble("x", underPaintInvalidation.x);
-                    underPaintInvalidationJSON->setDouble("y", underPaintInvalidation.y);
-                    underPaintInvalidationJSON->setString("oldPixel", Color(underPaintInvalidation.oldPixel).nameForLayoutTreeAsText());
-                    underPaintInvalidationJSON->setString("newPixel", Color(underPaintInvalidation.newPixel).nameForLayoutTreeAsText());
-                    underPaintInvalidationsJSON->pushObject(std::move(underPaintInvalidationJSON));
-                }
-                json->setArray("underPaintInvalidations", std::move(underPaintInvalidationsJSON));
-            }
-        }
-    }
+    rasterInvalidationTrackingMap().asJSON(this, json.get());
 
     if ((flags & LayerTreeIncludesPaintingPhases) && m_paintingPhase) {
         std::unique_ptr<JSONArray> paintingPhasesJSON = JSONArray::create();
         if (m_paintingPhase & GraphicsLayerPaintBackground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintBackground");
         if (m_paintingPhase & GraphicsLayerPaintForeground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintForeground");
         if (m_paintingPhase & GraphicsLayerPaintMask)
             paintingPhasesJSON->pushString("GraphicsLayerPaintMask");
         if (m_paintingPhase & GraphicsLayerPaintChildClippingMask)
@@ skipping 264 matching lines @@
     if (m_isRootForIsolatedGroup == isolated)
         return;
     m_isRootForIsolatedGroup = isolated;
     platformLayer()->setIsRootForIsolatedGroup(isolated);
 }
 
 void GraphicsLayer::setContentsNeedsDisplay()
 {
     if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
         contentsLayer->invalidate();
-        trackPaintInvalidation(*this, m_contentsRect, PaintInvalidationFull);
+        trackRasterInvalidation(*this, m_contentsRect, PaintInvalidationFull);
     }
 }
 
 void GraphicsLayer::setNeedsDisplay()
 {
     if (!drawsContent())
         return;
 
     // TODO(chrishtr): stop invalidating the rects once FrameView::paintRecursively does so.
     m_layer->layer()->invalidate();
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->invalidate();
     getPaintController().invalidateAll();
 
-    trackPaintInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)), PaintInvalidationFull);
+    trackRasterInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)), PaintInvalidationFull);
 }
 
 void GraphicsLayer::setNeedsDisplayInRect(const IntRect& rect, PaintInvalidationReason invalidationReason, const DisplayItemClient& client)
 {
     if (!drawsContent())
         return;
 
     m_layer->layer()->invalidateRect(rect);
     if (firstPaintInvalidationTrackingEnabled())
         m_debugInfo.appendAnnotatedInvalidateRect(rect, invalidationReason);
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->invalidate();
 
-    trackPaintInvalidation(client, rect, invalidationReason);
+    trackRasterInvalidation(client, rect, invalidationReason);
 }
 
 void GraphicsLayer::setContentsRect(const IntRect& rect)
 {
     if (rect == m_contentsRect)
         return;
 
     m_contentsRect = rect;
     updateContentsRect();
 }
@@ skipping 161 matching lines @@
         || pixelComponentsDiffer(SkColorGetR(p1), SkColorGetR(p2))
         || pixelComponentsDiffer(SkColorGetG(p1), SkColorGetG(p2))
         || pixelComponentsDiffer(SkColorGetB(p1), SkColorGetB(p2));
 }
 
 void GraphicsLayer::checkPaintUnderInvalidations(const SkPicture& newPicture)
 {
     if (!drawsContent())
         return;
 
-    auto it = paintInvalidationTrackingMap().find(this);
-    if (it == paintInvalidationTrackingMap().end())
-        return;
-    PaintInvalidationTracking& tracking = it->value;
-    if (!tracking.lastPaintedPicture)
+    RasterInvalidationTracking* tracking = rasterInvalidationTrackingMap().find(this);
+    if (!tracking)
         return;
 
-    IntRect rect = intersection(tracking.lastInterestRect, interestRect());
+    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);
         canvas.clear(SK_ColorTRANSPARENT);
         canvas.translate(-rect.x(), -rect.y());
-        canvas.drawPicture(tracking.lastPaintedPicture.get());
+        canvas.drawPicture(tracking->lastPaintedPicture.get());
     }
 
     SkBitmap newBitmap;
     newBitmap.allocPixels(SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
     {
         SkCanvas canvas(newBitmap);
         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) {
         int layerY = bitmapY + rect.y();
         for (int bitmapX = 0; bitmapX < rect.width(); ++bitmapX) {
             int layerX = bitmapX + rect.x();
             SkColor oldPixel = oldBitmap.getColor(bitmapX, bitmapY);
             SkColor newPixel = newBitmap.getColor(bitmapX, bitmapY);
-            if (pixelsDiffer(oldPixel, newPixel) && !tracking.paintInvalidationRegionSinceLastPaint.contains(IntPoint(layerX, layerY))) {
+            if (pixelsDiffer(oldPixel, newPixel) && !tracking->rasterInvalidationRegionSinceLastPaint.contains(IntPoint(layerX, layerY))) {
                 if (mismatchingPixels < maxMismatchesToReport) {
                     UnderPaintInvalidation underPaintInvalidation = { layerX, layerY, oldPixel, newPixel };
-                    tracking.underPaintInvalidations.append(underPaintInvalidation);
+                    tracking->underPaintInvalidations.append(underPaintInvalidation);
                     LOG(ERROR) << debugName() << " Uninvalidated old/new pixels mismatch at " << layerX << "," << layerY << " old:" << std::hex << oldPixel << " new:" << newPixel;
                 } else if (mismatchingPixels == maxMismatchesToReport) {
                     LOG(ERROR) << "and more...";
                 }
                 ++mismatchingPixels;
                 *newBitmap.getAddr32(bitmapX, bitmapY) = SkColorSetARGB(0xFF, 0xA0, 0, 0); // Dark red.
             } else {
                 *newBitmap.getAddr32(bitmapX, bitmapY) = SK_ColorTRANSPARENT;
             }
         }
@@ skipping 17 matching lines @@
 {
     if (!layer) {
         fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
         return;
     }
 
     String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
     fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif