Reuse cc::PictureLayers when possible for SPv2.

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"
@@ skipping 32 matching lines @@
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 namespace blink {
 
 class PaintArtifactCompositor::ContentLayerClientImpl : public cc::ContentLayerClient {
     WTF_MAKE_NONCOPYABLE(ContentLayerClientImpl);
     USING_FAST_MALLOC(ContentLayerClientImpl);
 public:
-    ContentLayerClientImpl(scoped_refptr<cc::DisplayItemList> list, const gfx::Rect& paintableRegion)
-        : m_ccDisplayItemList(std::move(list)), m_paintableRegion(paintableRegion) { }
+    ContentLayerClientImpl(Optional<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;
     }
 
+    scoped_refptr<cc::PictureLayer> ccPictureLayer() { return m_ccPictureLayer; }
+
+    bool matches(const PaintChunk& paintChunk)
+    {
+        return m_id && paintChunk.id && *m_id == *paintChunk.id;
+    }
+
 private:
+    Optional<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()));
@@ skipping 99 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
 
-scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset)
+std::unique_ptr<PaintArtifactCompositor::ContentLayerClientImpl> PaintArtifactCompositor::clientForPaintChunk(const PaintChunk& paintChunk)
+{
+    // TODO(chrishtr): for now, just using a linear walk. In the future we can optimize this by using the same techniques used in

[pdr., 2016/09/21 22:45:12]

Xianzhu, I think this looks good but can you triple-check?

[chrishtr, 2016/09/22 16:51:33]

FYI he commented on this earlier in the code review.

+    // PaintController for display lists.
+    for (auto& client : m_currentContentLayerClients) {
+        if (client && client->matches(paintChunk))
+            return std::move(client);
+    }
+    return wrapUnique(new ContentLayerClientImpl(paintChunk.id));
+}
+
+scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset,
+    Vector<std::unique_ptr<ContentLayerClientImpl>>& newContentLayerClients)
 {
     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 a layer for painted content.
+    // The common case: create or reuse a PictureLayer for painted content.
+    std::unique_ptr<ContentLayerClientImpl> contentLayerClient = clientForPaintChunk(paintChunk);
+
     gfx::Rect combinedBounds = enclosingIntRect(paintChunk.bounds);
     scoped_refptr<cc::DisplayItemList> displayList = recordPaintChunk(paintArtifact, paintChunk, combinedBounds);
-    std::unique_ptr<ContentLayerClientImpl> contentLayerClient = wrapUnique(
-        new ContentLayerClientImpl(std::move(displayList), gfx::Rect(combinedBounds.size())));
+    contentLayerClient->SetDisplayList(std::move(displayList));
+    contentLayerClient->SetPaintableRegion(gfx::Rect(combinedBounds.size()));
 
     layerOffset = combinedBounds.OffsetFromOrigin();
-    scoped_refptr<cc::PictureLayer> layer = cc::PictureLayer::Create(contentLayerClient.get());
-    layer->SetBounds(combinedBounds.size());
-    layer->SetIsDrawable(true);
+    scoped_refptr<cc::PictureLayer> ccPictureLayer = contentLayerClient->ccPictureLayer();
+    ccPictureLayer->SetBounds(combinedBounds.size());
+    ccPictureLayer->SetIsDrawable(true);
     if (paintChunk.knownToBeOpaque)
-        layer->SetContentsOpaque(true);
-    m_contentLayerClients.append(std::move(contentLayerClient));
-    return layer;
+        ccPictureLayer->SetContentsOpaque(true);
+    for (auto& invalidation : paintChunk.rasterInvalidationRects) {
+        IntRect rect(enclosingIntRect(invalidation));
+        gfx::Rect ccInvalidationRect(rect.x(), rect.y(), std::max(0, rect.width()), std::max(0, rect.height()));
+        // 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);
+    }
+
+    newContentLayerClients.append(std::move(contentLayerClient));
+    return ccPictureLayer;
 }
 
 namespace {
 
 class PropertyTreeManager {
     WTF_MAKE_NONCOPYABLE(PropertyTreeManager);
 public:
     PropertyTreeManager(cc::PropertyTrees& propertyTrees, cc::Layer* rootLayer)
         : m_propertyTrees(propertyTrees)
         , m_rootLayer(rootLayer)
@@ skipping 288 matching lines @@
     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());
 
-    m_contentLayerClients.clear();
-    m_contentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
+    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);
+        scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, layerOffset, newContentLayerClients);
 
         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);
 
         m_rootLayer->AddChild(layer);
         layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
         layer->SetTransformTreeIndex(transformId);
         layer->SetClipTreeIndex(clipId);
         layer->SetEffectTreeIndex(effectId);
         layer->SetScrollTreeIndex(scrollId);
 
         // TODO(jbroman): This probably shouldn't be necessary, but it is still
         // queried by RenderSurfaceImpl.
         layer->Set3dSortingContextId(layerTree->property_trees()->transform_tree.Node(transformId)->sorting_context_id);
 
         layer->SetShouldCheckBackfaceVisibility(paintChunk.properties.backfaceHidden);
 
         if (m_extraDataForTestingEnabled)
             m_extraDataForTesting->contentLayers.append(layer);
     }
+    m_currentContentLayerClients.clear();
+    m_currentContentLayerClients.swap(newContentLayerClients);
 
     // Mark the property trees as having been rebuilt.
     layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
     layerTree->property_trees()->needs_rebuild = false;
 }
 
 } // namespace blink