Add effect node support in PaintArtifactCompositor for layer list mode [4/4]

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 324 matching lines @@
     return layer;
 }
 
 namespace {
 
 class PropertyTreeManager {
     WTF_MAKE_NONCOPYABLE(PropertyTreeManager);
 public:
     PropertyTreeManager(cc::PropertyTrees& propertyTrees, cc::Layer* rootLayer)
         : m_propertyTrees(propertyTrees)
-        , m_rootLayer(rootLayer) {}
+        , m_rootLayer(rootLayer)
+#if DCHECK_IS_ON()
+        , m_isFirstEffectEver(true)
+#endif
+    {
+        m_effectStack.append(BlinkEffectAndCcIdPair{nullptr, kSecondaryRootNodeId});
+    }
 
     int compositorIdForTransformNode(const TransformPaintPropertyNode*);
     int compositorIdForClipNode(const ClipPaintPropertyNode*);
+    void switchToEffectNode(const EffectPaintPropertyNode& nextEffect);
+    int compositorIdForCurrentEffectNode() const { return m_effectStack.last().id; }
 
 private:
+    void buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect);
+
     cc::TransformTree& transformTree() { return m_propertyTrees.transform_tree; }
     cc::ClipTree& clipTree() { return m_propertyTrees.clip_tree; }
+    cc::EffectTree& effectTree() { return m_propertyTrees.effect_tree; }
+
+    const EffectPaintPropertyNode* currentEffectNode() { return m_effectStack.last().effect; }

[jbroman, 2016/07/08 18:32:34]

super-nit: for consistency with compositorIdForCurrentEffectNode(), make this
method const?

[trchen, 2016/07/09 01:09:24]

Done.

 
     // 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;
 
     // Maps from Blink-side property tree nodes to cc property node indices.
     HashMap<const TransformPaintPropertyNode*, int> m_transformNodeMap;
     HashMap<const ClipPaintPropertyNode*, int> m_clipNodeMap;
+
+    struct BlinkEffectAndCcIdPair {
+        const EffectPaintPropertyNode* effect;
+        int id;
+    };
+    Vector<BlinkEffectAndCcIdPair> m_effectStack;
+
+#if DCHECK_IS_ON()
+    HashSet<const EffectPaintPropertyNode*> m_effectNodesConverted;
+    bool m_isFirstEffectEver;
+#endif
 };
 
 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 58 matching lines @@
     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;
 }
 
+unsigned depth(const EffectPaintPropertyNode* node)
+{
+    unsigned result = 0;
+    for (; node; node = node->parent())
+        result++;
+    return result;
+}
+const EffectPaintPropertyNode* lowestCommonAncestor(const EffectPaintPropertyNode* nodeA, const EffectPaintPropertyNode* nodeB)

[jbroman, 2016/07/08 18:32:34]

super-nit: blank line above this function please

[trchen, 2016/07/09 01:09:25]

Done.

+{
+    // Optimized common case.
+    if (nodeA == nodeB)
+        return nodeA;
+
+    unsigned depthA = depth(nodeA), depthB = depth(nodeB);
+    while (depthA > depthB) {
+        nodeA = nodeA->parent();
+        depthA--;
+    }
+    while (depthB > depthA) {
+        nodeB = nodeB->parent();
+        depthB--;
+    }
+    DCHECK_EQ(depthA, depthB);
+    while (nodeA != nodeB) {
+        nodeA = nodeA->parent();
+        nodeB = nodeB->parent();
+    }
+    return nodeA;
+}
+
+void PropertyTreeManager::switchToEffectNode(const EffectPaintPropertyNode& nextEffect)
+{
+    const EffectPaintPropertyNode* ancestor = lowestCommonAncestor(currentEffectNode(), &nextEffect);
+    while (currentEffectNode() != ancestor)
+        m_effectStack.removeLast();
+
+#if DCHECK_IS_ON()
+    DCHECK(m_isFirstEffectEver || currentEffectNode()) << "Malformed effect tree. Nodes in the same property tree should have common root.";
+    m_isFirstEffectEver = false;
+#endif
+    buildEffectNodesRecursively(&nextEffect);
+}
+
+void PropertyTreeManager::buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect)
+{
+    if (nextEffect == currentEffectNode())
+        return;
+    DCHECK(nextEffect);
+
+    buildEffectNodesRecursively(nextEffect->parent());
+    DCHECK_EQ(nextEffect->parent(), currentEffectNode());
+
+#if DCHECK_IS_ON()
+    DCHECK(!m_effectNodesConverted.contains(nextEffect)) << "Malformed paint artifact. Paint chunks under the same effect should be contiguous.";
+    m_effectNodesConverted.add(nextEffect);
+#endif
+
+    // We currently create dummy layers to host effect nodes and corresponding render surface.
+    // This should be removed once cc implements better support for freestanding property trees.
+    scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
+    m_rootLayer->AddChild(dummyLayer);
+
+    // Also cc assumes a clip node is always created by a layer that creates render surface.
+    cc::ClipNode& dummyClip = *clipTree().Node(clipTree().Insert(cc::ClipNode(), kSecondaryRootNodeId));
+    dummyClip.owner_id = dummyLayer->id();
+    dummyClip.data.transform_id = kRealRootNodeId;

[jbroman, 2016/07/08 18:32:34]

It looks like they don't yet exist on EffectPaintPropertyNode, but I assume in
the future these will point at the appropriate transform/clip node for the
effect?

[trchen, 2016/07/09 01:09:25]

I don't think the dummy clip should even exist. Most effects don't come with an
intrinsic clip. The only exception I'm aware of is CSS filter.

Likewise, most effects are spatial independent. The only exception is blur
filter for which we need to specify the space of the blur radius.

[jbroman, 2016/07/09 20:25:24]

That's fair, but the effect will have an associated clip and transform.
Or a drop-shadow filter. Or a reference filter (<feOffset>, for instance). Or a
reflection.

+    dummyClip.data.target_id = kRealRootNodeId;
+
+    cc::EffectNode& effectNode = *effectTree().Node(effectTree().Insert(cc::EffectNode(), compositorIdForCurrentEffectNode()));
+    effectNode.owner_id = dummyLayer->id();
+    effectNode.data.clip_id = dummyClip.id;
+    effectNode.data.has_render_surface = true;
+    effectNode.data.opacity = nextEffect->opacity();
+    m_effectStack.append(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
+
+    dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
+    dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
+    dummyLayer->SetClipTreeIndex(dummyClip.id);
+    dummyLayer->SetEffectTreeIndex(effectNode.id);
+    dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
+}
+
 } // 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()) {
+        propertyTreeManager.switchToEffectNode(*paintChunk.properties.effect.get());

[jbroman, 2016/07/08 18:32:34]

nit: is there a reason this has to happen above the other logic, or could this
be grouped together with computing the ID for the transform and clip nodes
(possibly made even more similar if switchToEffectNode returned the ID)?

[trchen, 2016/07/09 01:09:25]

Done.

         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(clipId);
-        layer->SetEffectTreeIndex(kSecondaryRootNodeId);
+        layer->SetEffectTreeIndex(propertyTreeManager.compositorIdForCurrentEffectNode());
         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