Isolation of subtrees of stacking contexts and out-of-flow positioned objects

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 104 matching lines @@
     return list;
 }
 
 static gfx::Transform transformToTransformSpace(const TransformPaintPropertyNode* currentSpace, const TransformPaintPropertyNode* targetSpace)
 {
     TransformationMatrix matrix;
     while (currentSpace != targetSpace) {
         TransformationMatrix localMatrix = currentSpace->matrix();
         localMatrix.applyTransformOrigin(currentSpace->origin());
         matrix = localMatrix * matrix;
-        currentSpace = currentSpace->parent();
+        currentSpace = currentSpace->nonIsolationParent();
     }
     return gfx::Transform(TransformationMatrix::toSkMatrix44(matrix));
 }
 
 const TransformPaintPropertyNode* localTransformSpace(const ClipPaintPropertyNode* clip)
 {
-    return clip ? clip->localTransformSpace() : nullptr;
+    if (!clip)
+        return nullptr;
+    DCHECK(!clip->isIsolationNode());
+    if (const TransformPaintPropertyNode* transform = clip->localTransformSpace())
+        return transform->nonIsolationNode();
+    return nullptr;
 }
 
 scoped_refptr<cc::Layer> createClipLayer(const ClipPaintPropertyNode* node)
 {
     // TODO(jbroman): Handle rounded-rect clips.
     // TODO(jbroman): Handle clips of non-integer size.
     gfx::RectF clipRect = node->clipRect().rect();
 
     // TODO(jbroman): This, and the similar logic in
     // PaintArtifactCompositor::update, will need to be updated to account for
     // other kinds of intermediate layers, such as those that apply effects.
     // TODO(jbroman): This assumes that the transform space of this node's
     // parent is an ancestor of this node's transform space. That's not
     // necessarily true, and this should be fixed. crbug.com/597156
-    gfx::Transform transform = transformToTransformSpace(localTransformSpace(node), localTransformSpace(node->parent()));
+    const ClipPaintPropertyNode* parentClip = node->nonIsolationParent();
+    gfx::Transform transform = transformToTransformSpace(localTransformSpace(node), localTransformSpace(parentClip));
     gfx::Vector2dF offset = clipRect.OffsetFromOrigin();
     transform.Translate(offset.x(), offset.y());
-    if (node->parent()) {
-        FloatPoint offsetDueToParentClipOffset = node->parent()->clipRect().rect().location();
+    if (parentClip) {
+        FloatPoint offsetDueToParentClipOffset = parentClip->clipRect().rect().location();
         gfx::Transform undoClipOffset;
         undoClipOffset.Translate(-offsetDueToParentClipOffset.x(), -offsetDueToParentClipOffset.y());
         transform.ConcatTransform(undoClipOffset);
     }
 
     scoped_refptr<cc::Layer> layer = cc::Layer::Create();
     layer->SetIsDrawable(false);
     layer->SetMasksToBounds(true);
     layer->SetPosition(gfx::PointF());
     layer->SetBounds(gfx::ToRoundedSize(clipRect.size()));
@@ skipping 23 matching lines @@
         // Otherwise, we need to build new clip layers.
         // We do this from the bottom up.
         size_t numExistingClipLayers = m_clipLayers.size();
         scoped_refptr<cc::Layer> childLayer;
         do {
             scoped_refptr<cc::Layer> clipLayer = createClipLayer(clip);
             m_clipLayers.append(NodeLayerPair(clip, clipLayer.get()));
             if (childLayer)
                 clipLayer->AddChild(std::move(childLayer));
             childLayer = std::move(clipLayer);
-            clip = clip->parent();
+            clip = clip->nonIsolationParent();
         } while (ancestor != clip);
         ancestorClipLayer->AddChild(std::move(childLayer));
 
         // Rearrange the new clip layers to be in top-down order, like they
         // should be.
         std::reverse(m_clipLayers.begin() + numExistingClipLayers, m_clipLayers.end());
 
         // Return the last (bottom-most) clip layer.
         return m_clipLayers.last().second;
     }
@@ skipping 75 matching lines @@
         return;
     }
 
     // TODO(jbroman): This should be incremental.
     m_rootLayer->RemoveAllChildren();
     m_contentLayerClients.clear();
 
     m_contentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
     ClipLayerManager clipLayerManager(m_rootLayer.get());
     for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
-        cc::Layer* parent = clipLayerManager.switchToNewClipLayer(paintChunk.properties.clip.get());
+        const ClipPaintPropertyNode* clip = paintChunk.properties.clip->nonIsolationNode();
+        cc::Layer* parent = clipLayerManager.switchToNewClipLayer(clip);
 
         gfx::Vector2dF layerOffset;
         scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, layerOffset);
         // TODO(jbroman): Same as above. This assumes the transform space of the current clip is
         // an ancestor of the chunk. It is not necessarily true. crbug.com/597156
-        gfx::Transform transform = transformToTransformSpace(paintChunk.properties.transform.get(), localTransformSpace(paintChunk.properties.clip.get()));
+        gfx::Transform transform = transformToTransformSpace(paintChunk.properties.transform->nonIsolationNode(), localTransformSpace(clip));
         transform.Translate(layerOffset.x(), layerOffset.y());
         // If a clip was applied, its origin needs to be cancelled out in
         // this transform.
-        if (const auto* clip = paintChunk.properties.clip.get()) {
+        if (clip) {
             FloatPoint offsetDueToClipOffset = clip->clipRect().rect().location();
             gfx::Transform undoClipOffset;
             undoClipOffset.Translate(-offsetDueToClipOffset.x(), -offsetDueToClipOffset.y());
             transform.ConcatTransform(undoClipOffset);
         }
         layer->SetTransform(transform);
         layer->SetDoubleSided(!paintChunk.properties.backfaceHidden);
         layer->SetNeedsDisplay();
         parent->AddChild(layer);
 
@@ skipping 81 matching lines @@
 int PropertyTreeManager::compositorIdForTransformNode(const TransformPaintPropertyNode* transformNode)
 {
     if (!transformNode)
         return kSecondaryRootNodeId;
 
     auto it = m_transformNodeMap.find(transformNode);
     if (it != m_transformNodeMap.end())
         return it->value;
 
     scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
-    int parentId = compositorIdForTransformNode(transformNode->parent());
+    int parentId = compositorIdForTransformNode(transformNode->nonIsolationParent());
     int id = transformTree().Insert(cc::TransformNode(), parentId);
 
     cc::TransformNode& compositorNode = *transformTree().Node(id);
     transformTree().SetTargetId(id, kRealRootNodeId);
     transformTree().SetContentTargetId(id, kRealRootNodeId);
     compositorNode.source_node_id = parentId;
 
     FloatPoint3D origin = transformNode->origin();
     compositorNode.pre_local.matrix().setTranslate(
         -origin.x(), -origin.y(), -origin.z());
@@ skipping 18 matching lines @@
 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 parentId = compositorIdForClipNode(clipNode->nonIsolationParent());
     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.clip = clipNode->clipRect().rect();
-    compositorNode.transform_id = compositorIdForTransformNode(clipNode->localTransformSpace());
+    compositorNode.transform_id = compositorIdForTransformNode(localTransformSpace(clipNode));
     compositorNode.target_transform_id = kRealRootNodeId;
     compositorNode.applies_local_clip = true;
     compositorNode.layers_are_clipped = true;
     compositorNode.layers_are_clipped_when_surfaces_disabled = true;
 
     m_rootLayer->AddChild(dummyLayer);
     dummyLayer->SetTransformTreeIndex(compositorNode.transform_id);
     dummyLayer->SetClipTreeIndex(id);
     dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
     dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
@@ skipping 26 matching lines @@
     }
     while (depthB > depthA) {
         nodeB = nodeB->parent();
         depthB--;
     }
     DCHECK_EQ(depthA, depthB);
     while (nodeA != nodeB) {
         nodeA = nodeA->parent();
         nodeB = nodeB->parent();
     }
-    return nodeA;
+    return nodeA ? nodeA->nonIsolationNode() : nullptr;
 }
 
 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());
+    buildEffectNodesRecursively(nextEffect->nonIsolationParent());
+    DCHECK_EQ(nextEffect->nonIsolationParent(), 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);
@@ skipping 32 matching lines @@
     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());
+        int transformId = propertyTreeManager.compositorIdForTransformNode(paintChunk.properties.transform->nonIsolationNode());
+        int clipId = propertyTreeManager.compositorIdForClipNode(paintChunk.properties.clip->nonIsolationNode());
+        int effectId = propertyTreeManager.switchToEffectNode(*paintChunk.properties.effect->nonIsolationNode());
 
         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(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