Switch to null root property tree nodes [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 200 matching lines @@
 }
 
 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});
     }
 
     // TODO(pdr): This will need to be unified with how viewport scale works.
     void setDeviceScaleFactor(float);
 
     int compositorIdForTransformNode(const TransformPaintPropertyNode*);
     int compositorIdForClipNode(const ClipPaintPropertyNode*);
-    int switchToEffectNode(const EffectPaintPropertyNode& nextEffect);
+    int switchToEffectNode(const EffectPaintPropertyNode* nextEffect);
     int compositorIdForCurrentEffectNode() const { return m_effectStack.last().id; }
     int compositorIdForScrollNode(const ScrollPaintPropertyNode*);
 
     // Scroll offset has special treatment in the transform and scroll trees.
     void updateScrollOffset(int layerId, int scrollId);
 
 private:
     void buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect);
 
     cc::TransformTree& transformTree() { return m_propertyTrees.transform_tree; }
@@ skipping 16 matching lines @@
     HashMap<const ScrollPaintPropertyNode*, int> m_scrollNodeMap;
 
     struct BlinkEffectAndCcIdPair {
         const EffectPaintPropertyNode* effect;
         int id;
     };
     Vector<BlinkEffectAndCcIdPair> m_effectStack;
 
 #if DCHECK_IS_ON()
     HashSet<const EffectPaintPropertyNode*> m_effectNodesConverted;
-    bool m_isFirstEffectEver;
 #endif
 };
 
 void PropertyTreeManager::setDeviceScaleFactor(float deviceScaleFactor)
 {
     auto& rootTransformNode = *transformTree().Node(kSecondaryRootNodeId);
     rootTransformNode.local.Scale(deviceScaleFactor, deviceScaleFactor);
 }
 
 int PropertyTreeManager::compositorIdForTransformNode(const TransformPaintPropertyNode* transformNode)
@@ skipping 147 matching lines @@
         depthB--;
     }
     DCHECK_EQ(depthA, depthB);
     while (nodeA != nodeB) {
         nodeA = nodeA->parent();
         nodeB = nodeB->parent();
     }
     return nodeA;
 }
 
-int PropertyTreeManager::switchToEffectNode(const EffectPaintPropertyNode& nextEffect)
+int PropertyTreeManager::switchToEffectNode(const EffectPaintPropertyNode* nextEffect)
 {
-    const EffectPaintPropertyNode* ancestor = lowestCommonAncestor(currentEffectNode(), &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);
+    if (!nextEffect)
+        return kSecondaryRootNodeId;
+
+    buildEffectNodesRecursively(nextEffect);
 
     return compositorIdForCurrentEffectNode();
 }
 
 void PropertyTreeManager::buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect)
 {
     if (nextEffect == currentEffectNode())
         return;
     DCHECK(nextEffect);
 
@@ skipping 59 matching lines @@
 
     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 scrollId = propertyTreeManager.compositorIdForScrollNode(paintChunk.properties.scroll.get());
         int clipId = propertyTreeManager.compositorIdForClipNode(paintChunk.properties.clip.get());
-        int effectId = propertyTreeManager.switchToEffectNode(*paintChunk.properties.effect.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);
     }
 
     // Mark the property trees as having been rebuilt.
     layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
     layerTree->property_trees()->needs_rebuild = false;
 }
 
 } // namespace blink