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

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/playback/transform_display_item.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/ForeignLayerDisplayItem.h"
 #include "platform/graphics/paint/GeometryPropertyTreeState.h"
 #include "platform/graphics/paint/PaintArtifact.h"
+#include "platform/graphics/paint/RasterInvalidationTracking.h"
 #include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebLayer.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/skia_util.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 namespace blink {
 
+template class RasterInvalidationTrackingMap<const cc::Layer>;
+static RasterInvalidationTrackingMap<const cc::Layer>&
+ccLayersRasterInvalidationTrackingMap() {
+  DEFINE_STATIC_LOCAL(RasterInvalidationTrackingMap<const cc::Layer>, map, ());
+  return map;
+}
+
+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;
+}
+
 class PaintArtifactCompositor::ContentLayerClientImpl
     : public cc::ContentLayerClient {
   WTF_MAKE_NONCOPYABLE(ContentLayerClientImpl);
   USING_FAST_MALLOC(ContentLayerClientImpl);
 
  public:
-  ContentLayerClientImpl(Optional<DisplayItem::Id> paintChunkId)
-      : m_id(paintChunkId), m_ccPictureLayer(cc::PictureLayer::Create(this)) {}
+  ContentLayerClientImpl(DisplayItem::Id paintChunkId)
+      : m_id(paintChunkId),
+        m_debugName(paintChunkId.client.debugName()),
+        m_ccPictureLayer(cc::PictureLayer::Create(this)) {}
 
   void SetDisplayList(scoped_refptr<cc::DisplayItemList> ccDisplayItemList) {
     m_ccDisplayItemList = std::move(ccDisplayItemList);
   }
   void SetPaintableRegion(gfx::Rect region) { m_paintableRegion = region; }
 
   // cc::ContentLayerClient
   gfx::Rect PaintableRegion() override { return m_paintableRegion; }
   scoped_refptr<cc::DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting) override {
     return m_ccDisplayItemList;
   }
   bool FillsBoundsCompletely() const override { return false; }
   size_t GetApproximateUnsharedMemoryUsage() const override {
     // TODO(jbroman): Actually calculate memory usage.
     return 0;
   }
 
+  void resetTrackedRasterInvalidations() {
+    RasterInvalidationTracking* tracking =
+        ccLayersRasterInvalidationTrackingMap().find(m_ccPictureLayer.get());
+    if (!tracking)
+      return;
+
+    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
+      tracking->trackedRasterInvalidations.clear();
+    else
+      ccLayersRasterInvalidationTrackingMap().remove(m_ccPictureLayer.get());
+  }
+
+  bool hasTrackedRasterInvalidations() const {
+    RasterInvalidationTracking* tracking =
+        ccLayersRasterInvalidationTrackingMap().find(m_ccPictureLayer.get());
+    if (tracking)
+      return !tracking->trackedRasterInvalidations.isEmpty();
+    return false;
+  }
+
+  void setNeedsDisplayRect(const gfx::Rect& rect,
+                           RasterInvalidationInfo* rasterInvalidationInfo) {
+    m_ccPictureLayer->SetNeedsDisplayRect(rect);
+
+    if (!rasterInvalidationInfo || rect.IsEmpty())
+      return;
+
+    RasterInvalidationTracking& tracking =
+        ccLayersRasterInvalidationTrackingMap().add(m_ccPictureLayer.get());
+
+    tracking.trackedRasterInvalidations.append(*rasterInvalidationInfo);
+
+    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+      // TODO(crbug.com/496260): Some antialiasing effects overflows the paint invalidation rect.
+      IntRect r = rasterInvalidationInfo->rect;
+      r.inflate(1);
+      tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
+    }
+  }
+
+  std::unique_ptr<JSONObject> layerAsJSON() {
+    std::unique_ptr<JSONObject> json = JSONObject::create();
+    json->setString("name", m_debugName);
+    IntSize bounds(m_ccPictureLayer->bounds().width(),
+                   m_ccPictureLayer->bounds().height());
+    if (!bounds.isEmpty())
+      json->setArray("bounds", sizeAsJSONArray(bounds));
+    json->setBoolean("contentsOpaque", m_ccPictureLayer->contents_opaque());
+    json->setBoolean("drawsContent", m_ccPictureLayer->DrawsContent());
+
+    ccLayersRasterInvalidationTrackingMap().asJSON(m_ccPictureLayer.get(),
+                                                   json.get());
+    return json;
+  }
+
   scoped_refptr<cc::PictureLayer> ccPictureLayer() { return m_ccPictureLayer; }
 
   bool matches(const PaintChunk& paintChunk) {
-    return m_id && paintChunk.id && *m_id == *paintChunk.id;
+    return paintChunk.id && m_id == *paintChunk.id;
   }
 
  private:
-  Optional<PaintChunk::Id> m_id;
+  PaintChunk::Id m_id;
+  String m_debugName;
   scoped_refptr<cc::PictureLayer> m_ccPictureLayer;
   scoped_refptr<cc::DisplayItemList> m_ccDisplayItemList;
   gfx::Rect m_paintableRegion;
 };
 
 PaintArtifactCompositor::PaintArtifactCompositor() {
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
   m_rootLayer = cc::Layer::Create();
   m_webLayer = wrapUnique(
       Platform::current()->compositorSupport()->createLayerFromCCLayer(
           m_rootLayer.get()));
+  m_isTrackingRasterInvalidations = false;
 }
 
 PaintArtifactCompositor::~PaintArtifactCompositor() {}
 
+void PaintArtifactCompositor::setTracksRasterInvalidations(
+    bool tracksPaintInvalidations) {
+  resetTrackedRasterInvalidations();
+  m_isTrackingRasterInvalidations = tracksPaintInvalidations;
+}
+
+void PaintArtifactCompositor::resetTrackedRasterInvalidations() {
+  for (auto& client : m_contentLayerClients)
+    client->resetTrackedRasterInvalidations();
+}
+
+bool PaintArtifactCompositor::hasTrackedRasterInvalidations() const {
+  for (auto& client : m_contentLayerClients) {
+    if (client->hasTrackedRasterInvalidations())
+      return true;
+  }
+  return false;
+}
+
+std::unique_ptr<JSONObject> PaintArtifactCompositor::layersAsJSON(
+    LayerTreeFlags flags) const {
+  std::unique_ptr<JSONArray> layersJSON = JSONArray::create();
+  for (const auto& client : m_contentLayerClients) {
+    layersJSON->pushObject(client->layerAsJSON());
+  }
+  std::unique_ptr<JSONObject> json = JSONObject::create();
+  json->setArray("layers", std::move(layersJSON));
+  return json;
+}
+
 namespace {
 
 static gfx::Rect largeRect(-200000, -200000, 400000, 400000);
 
 static void appendDisplayItemToCcDisplayItemList(const DisplayItem& displayItem,
                                                  cc::DisplayItemList* list) {
   if (DisplayItem::isDrawingType(displayItem.getType())) {
     const SkPicture* picture =
         static_cast<const DrawingDisplayItem&>(displayItem).picture();
     if (!picture)
@@ skipping 97 matching lines @@
   cc::ScrollNode& scrollNode =
       *scrollTree.Node(scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId));
   DCHECK_EQ(scrollNode.id, kSecondaryRootNodeId);
   scrollNode.owner_id = ownerId;
   scrollNode.transform_id = kRealRootNodeId;
 }
 
 }  // namespace
 
 std::unique_ptr<PaintArtifactCompositor::ContentLayerClientImpl>
-PaintArtifactCompositor::clientForPaintChunk(const PaintChunk& paintChunk) {
+PaintArtifactCompositor::clientForPaintChunk(
+    const PaintChunk& paintChunk,
+    const PaintArtifact& paintArtifact) {
   // TODO(chrishtr): for now, just using a linear walk. In the future we can optimize this by using the same techniques used in
   // PaintController for display lists.
   for (auto& client : m_contentLayerClients) {
     if (client && client->matches(paintChunk))
       return std::move(client);
   }
-  return wrapUnique(new ContentLayerClientImpl(paintChunk.id));
+
+  return wrapUnique(new ContentLayerClientImpl(
+      paintChunk.id
+          ? *paintChunk.id
+          : paintArtifact.getDisplayItemList()[paintChunk.beginIndex].getId()));
 }
 
 scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(
     const PaintArtifact& paintArtifact,
     const PaintChunk& paintChunk,
     gfx::Vector2dF& layerOffset,
-    Vector<std::unique_ptr<ContentLayerClientImpl>>& newContentLayerClients) {
+    Vector<std::unique_ptr<ContentLayerClientImpl>>& newContentLayerClients,
+    RasterInvalidationTracking* tracking) {
   DCHECK(paintChunk.size());
 
   // If the paint chunk is a foreign layer, just return that layer.
   if (scoped_refptr<cc::Layer> foreignLayer =
           foreignLayerForPaintChunk(paintArtifact, paintChunk, layerOffset))
     return foreignLayer;
 
   // The common case: create or reuse a PictureLayer for painted content.
   std::unique_ptr<ContentLayerClientImpl> contentLayerClient =
-      clientForPaintChunk(paintChunk);
+      clientForPaintChunk(paintChunk, paintArtifact);
 
   gfx::Rect combinedBounds = enclosingIntRect(paintChunk.bounds);
   scoped_refptr<cc::DisplayItemList> displayList =
       recordPaintChunk(paintArtifact, paintChunk, combinedBounds);
   contentLayerClient->SetDisplayList(std::move(displayList));
   contentLayerClient->SetPaintableRegion(gfx::Rect(combinedBounds.size()));
 
   layerOffset = combinedBounds.OffsetFromOrigin();
   scoped_refptr<cc::PictureLayer> ccPictureLayer =
       contentLayerClient->ccPictureLayer();
   ccPictureLayer->SetBounds(combinedBounds.size());
   ccPictureLayer->SetIsDrawable(true);
   if (paintChunk.knownToBeOpaque)
     ccPictureLayer->SetContentsOpaque(true);
-  for (auto& invalidation : paintChunk.rasterInvalidationRects) {
-    IntRect rect(enclosingIntRect(invalidation));
+  DCHECK(!tracking ||
+         tracking->trackedRasterInvalidations.size() ==
+             paintChunk.rasterInvalidationRects.size());
+  for (unsigned index = 0; index < paintChunk.rasterInvalidationRects.size();
+       ++index) {
+    IntRect rect(enclosingIntRect(paintChunk.rasterInvalidationRects[index]));
     gfx::Rect ccInvalidationRect(rect.x(), rect.y(), std::max(0, rect.width()),
                                  std::max(0, rect.height()));
+    ccInvalidationRect.Offset(-combinedBounds.OffsetFromOrigin());
     // Raster paintChunk.rasterInvalidationRects is in the space of the containing transform node, so need to subtract off the layer offset.
-    ccInvalidationRect.Offset(-combinedBounds.OffsetFromOrigin());
-    ccPictureLayer->SetNeedsDisplayRect(ccInvalidationRect);
+    contentLayerClient->setNeedsDisplayRect(
+        ccInvalidationRect,
+        tracking ? &tracking->trackedRasterInvalidations[index] : nullptr);
   }
 
   newContentLayerClients.append(std::move(contentLayerClient));
   return ccPictureLayer;
 }
 
 namespace {
 
 class PropertyTreeManager {
   WTF_MAKE_NONCOPYABLE(PropertyTreeManager);
@@ skipping 289 matching lines @@
 
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(dummyClip.id);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace
 
-void PaintArtifactCompositor::update(const PaintArtifact& paintArtifact) {
+void PaintArtifactCompositor::update(
+    const PaintArtifact& paintArtifact,
+    RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations) {
   DCHECK(m_rootLayer);
 
   cc::LayerTree* layerTree = m_rootLayer->GetLayerTree();
 
   // The tree will be null after detaching and this update can be ignored.
   // See: WebViewImpl::detachPaintArtifactCompositor().
   if (!layerTree)
     return;
 
   if (m_extraDataForTestingEnabled)
@@ skipping 10 matching lines @@
 
   PropertyTreeManager propertyTreeManager(*layerTree->property_trees(),
                                           m_rootLayer.get());
   propertyTreeManager.setDeviceScaleFactor(layerTree->device_scale_factor());
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = layerForPaintChunk(
-        paintArtifact, paintChunk, layerOffset, newContentLayerClients);
+        paintArtifact, paintChunk, layerOffset, newContentLayerClients,
+        rasterChunkInvalidations ? rasterChunkInvalidations->find(&paintChunk)
+                                 : nullptr);
 
     int transformId = propertyTreeManager.compositorIdForTransformNode(
         paintChunk.properties.transform.get());
     int scrollId = propertyTreeManager.compositorIdForScrollNode(
         paintChunk.properties.scroll.get());
     int clipId = propertyTreeManager.compositorIdForClipNode(
         paintChunk.properties.clip.get());
     int effectId = propertyTreeManager.switchToEffectNode(
         *paintChunk.properties.effect.get());
 
@@ skipping 22 matching lines @@
   }
   m_contentLayerClients.clear();
   m_contentLayerClients.swap(newContentLayerClients);
 
   // Mark the property trees as having been rebuilt.
   layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
   layerTree->property_trees()->needs_rebuild = false;
 }
 
 }  // namespace blink