[SPv2] Build simple cc clip trees from Blink clip trees.

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 327 matching lines @@
 namespace {
 
 class PropertyTreeManager {
     WTF_MAKE_NONCOPYABLE(PropertyTreeManager);
 public:
     PropertyTreeManager(cc::PropertyTrees& propertyTrees, cc::Layer* rootLayer)
         : m_propertyTrees(propertyTrees)
         , m_rootLayer(rootLayer) {}
 
     int compositorIdForTransformNode(const TransformPaintPropertyNode*);
+    int compositorIdForClipNode(const ClipPaintPropertyNode*);
 
 private:
     cc::TransformTree& transformTree() { return m_propertyTrees.transform_tree; }
+    cc::ClipTree& clipTree() { return m_propertyTrees.clip_tree; }
 
     // Property trees which should be updated by the manager.
     cc::PropertyTrees& m_propertyTrees;
 
     // Layer to which transform "owner" layers should be added. These will not
     // have any actual children, but at present must exist in the tree.
     cc::Layer* m_rootLayer;
 
-    // Map from Blink-side transform nodes to cc transform node indices.
+    // Maps from Blink-side property tree nodes to cc property node indices.
     HashMap<const TransformPaintPropertyNode*, int> m_transformNodeMap;
+    HashMap<const ClipPaintPropertyNode*, int> m_clipNodeMap;
 };
 
 int PropertyTreeManager::compositorIdForTransformNode(const TransformPaintPropertyNode* transformNode)
 {
     if (!transformNode)
         return kSecondaryRootNodeId;
 
     auto it = m_transformNodeMap.find(transformNode);
     if (it != m_transformNodeMap.end())
         return it->value;
@@ skipping 21 matching lines @@
     dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
     dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
     dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
 
     auto result = m_transformNodeMap.set(transformNode, id);
     DCHECK(result.isNewEntry);
     transformTree().set_needs_update(true);
     return id;
 }
 
+int PropertyTreeManager::compositorIdForClipNode(const ClipPaintPropertyNode* clipNode)
+{
+    if (!clipNode)
+        return kSecondaryRootNodeId;
+
+    auto it = m_clipNodeMap.find(clipNode);
+    if (it != m_clipNodeMap.end())
+        return it->value;
+
+    scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
+    int parentId = compositorIdForClipNode(clipNode->parent());
+    int id = clipTree().Insert(cc::ClipNode(), parentId);
+
+    cc::ClipNode& compositorNode = *clipTree().Node(id);
+    compositorNode.owner_id = dummyLayer->id();
+
+    // TODO(jbroman): Don't discard rounded corners.
+    compositorNode.data.clip = clipNode->clipRect().rect();
+    compositorNode.data.transform_id = compositorIdForTransformNode(clipNode->localTransformSpace());
+    compositorNode.data.target_id = kRealRootNodeId;
+    compositorNode.data.applies_local_clip = true;
+    compositorNode.data.layers_are_clipped = true;
+    compositorNode.data.layers_are_clipped_when_surfaces_disabled = true;
+
+    m_rootLayer->AddChild(dummyLayer);
+    dummyLayer->SetTransformTreeIndex(compositorNode.data.transform_id);
+    dummyLayer->SetClipTreeIndex(id);
+    dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
+    dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
+    dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
+
+    auto result = m_clipNodeMap.set(clipNode, id);
+    DCHECK(result.isNewEntry);
+    clipTree().set_needs_update(true);
+    return id;
+}
+
 } // namespace
 
 void PaintArtifactCompositor::updateInLayerListMode(const PaintArtifact& paintArtifact)
 {
     cc::LayerTreeHost* host = m_rootLayer->layer_tree_host();
 
     setMinimalPropertyTrees(host->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(*host->property_trees(), m_rootLayer.get());
     m_contentLayerClients.clear();
     m_contentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
     for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
         gfx::Vector2dF layerOffset;
         scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, layerOffset);
 
         int transformId = propertyTreeManager.compositorIdForTransformNode(paintChunk.properties.transform.get());
+        int clipId = propertyTreeManager.compositorIdForClipNode(paintChunk.properties.clip.get());
+
         layer->set_offset_to_transform_parent(layerOffset);
 
         m_rootLayer->AddChild(layer);
         layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
         layer->SetTransformTreeIndex(transformId);
-        layer->SetClipTreeIndex(kSecondaryRootNodeId);
+        layer->SetClipTreeIndex(clipId);
         layer->SetEffectTreeIndex(kSecondaryRootNodeId);
         layer->SetScrollTreeIndex(kRealRootNodeId);
 
         if (m_extraDataForTestingEnabled)
             m_extraDataForTesting->contentLayers.append(layer);
     }
 
     // Mark the property trees as having been rebuilt.
     host->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
     host->property_trees()->needs_rebuild = false;
 }
 
 } // namespace blink