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)
+    ContentLayerClientImpl(DisplayItem::Id paintChunkId)
         : m_id(paintChunkId), 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_id.client.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;
     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)
             return;
@@ skipping 83 matching lines @@
     cc::ScrollTree& scrollTree = propertyTrees->scroll_tree;
     scrollTree.clear();
     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)
+std::unique_ptr<PaintArtifactCompositor::ContentLayerClientImpl> 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);
+    std::unique_ptr<ContentLayerClientImpl> contentLayerClient = 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 266 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)
         m_extraDataForTesting = wrapUnique(new ExtraDataForTesting);
 
     setMinimalPropertyTrees(layerTree->property_trees(), m_rootLayer->id());
 
     m_rootLayer->RemoveAllChildren();
     m_rootLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
     m_rootLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
     m_rootLayer->SetClipTreeIndex(kSecondaryRootNodeId);
     m_rootLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
     m_rootLayer->SetScrollTreeIndex(kRealRootNodeId);
 
     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);
+        scoped_refptr<cc::Layer> layer = layerForPaintChunk(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());
 
         propertyTreeManager.updateScrollOffset(layer->id(), scrollId);
 
         layer->set_offset_to_transform_parent(layerOffset);
 
@@ skipping 15 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