Revert of 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 327 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)
-#if DCHECK_IS_ON()
-        , m_isFirstEffectEver(true)
-#endif
-    {
-        m_effectStack.append(BlinkEffectAndCcIdPair{nullptr, kSecondaryRootNodeId});
-    }
+        , m_rootLayer(rootLayer) {}
 
     int compositorIdForTransformNode(const TransformPaintPropertyNode*);
     int compositorIdForClipNode(const ClipPaintPropertyNode*);
-    int 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() const { return m_effectStack.last().effect; }
 
     // 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)
-{
-    // 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;
-}
-
-int 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);
-
-    return compositorIdForCurrentEffectNode();
-}
-
-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.transform_id = kRealRootNodeId;
-    dummyClip.target_transform_id = kRealRootNodeId;
-
-    cc::EffectNode& effectNode = *effectTree().Node(effectTree().Insert(cc::EffectNode(), compositorIdForCurrentEffectNode()));
-    effectNode.owner_id = dummyLayer->id();
-    effectNode.clip_id = dummyClip.id;
-    effectNode.has_render_surface = true;
-    effectNode.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()) {
         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());
-        int effectId = propertyTreeManager.switchToEffectNode(*paintChunk.properties.effect.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(effectId);
+        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