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() {
-  DEFINE_STATIC_LOCAL(PaintInvalidationTrackingMap, map, ());
+template class RasterInvalidationTrackingMap<const GraphicsLayer>;
+static RasterInvalidationTrackingMap<const GraphicsLayer>&
+rasterInvalidationTrackingMap() {
+  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) {
 #if ENABLE(ASSERT)
@@ 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;
 }
 
 void GraphicsLayer::setHasWillChangeTransformHint(bool hasWillChangeTransform) {
@@ skipping 123 matching lines @@
 }
 
 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)
@@ skipping 177 matching lines @@
 
 GraphicsLayerDebugInfo& GraphicsLayer::debugInfo() {
   return m_debugInfo;
 }
 
 WebLayer* GraphicsLayer::contentsLayerIfRegistered() {
   clearContentsLayerIfUnregistered();
   return m_contentsLayer;
 }
 
-void GraphicsLayer::setTracksPaintInvalidations(bool tracksPaintInvalidations) {
-  resetTrackedPaintInvalidations();
-  m_isTrackingPaintInvalidations = tracksPaintInvalidations;
+void GraphicsLayer::setTracksRasterInvalidations(
+    bool tracksRasterInvalidations) {
+  resetTrackedRasterInvalidations();
+  m_isTrackingRasterInvalidations = tracksRasterInvalidations;
 }
 
-void GraphicsLayer::resetTrackedPaintInvalidations() {
-  auto it = paintInvalidationTrackingMap().find(this);
-  if (it == paintInvalidationTrackingMap().end())
+void GraphicsLayer::resetTrackedRasterInvalidations() {
+  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 {
-  PaintInvalidationTrackingMap::iterator it =
-      paintInvalidationTrackingMap().find(this);
-  if (it != paintInvalidationTrackingMap().end())
-    return !it->value.trackedPaintInvalidations.isEmpty();
+bool GraphicsLayer::hasTrackedRasterInvalidations() const {
+  RasterInvalidationTracking* tracking =
+      rasterInvalidationTrackingMap().find(this);
+  if (tracking)
+    return !tracking->trackedRasterInvalidations.isEmpty();
   return false;
 }
 
-void GraphicsLayer::trackPaintInvalidation(const DisplayItemClient& client,
-                                           const IntRect& rect,
-                                           PaintInvalidationReason reason) {
-  if (!isTrackingOrCheckingPaintInvalidations() || rect.isEmpty())
+void GraphicsLayer::trackRasterInvalidation(const DisplayItemClient& client,
+                                            const IntRect& rect,
+                                            PaintInvalidationReason reason) {
+  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();
     row->pushDouble(roundCloseToZero(t.m11()));
@@ skipping 103 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));
-      }
-    }
-  }
+  if (flags & LayerTreeIncludesPaintInvalidations)
+    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 253 matching lines @@
 void GraphicsLayer::setIsRootForIsolatedGroup(bool isolated) {
   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 154 matching lines @@
   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) {
   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(
+          !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.
@@ skipping 21 matching lines @@
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
     return;
   }
 
   String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
   fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif