[SPv2] Begin to convert the Blink transform tree to cc.

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"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/playback/transform_display_item.h"
 #include "cc/trees/layer_tree_host.h"
+#include "cc/trees/property_tree.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/ForeignLayerDisplayItem.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebLayer.h"
@@ skipping 237 matching lines @@
 static const int kSecondaryRootNodeId = 1;
 static const int kPropertyTreeSequenceNumber = 1;
 
 // Creates a minimal set of property trees for the compositor.
 void setMinimalPropertyTrees(cc::PropertyTrees* propertyTrees, int ownerId)
 {
     // cc's property trees expect a child of the actual root to be used. So we
     // need to create and populate an additional node for each type of tree.
 
     cc::TransformTree& transformTree = propertyTrees->transform_tree;
-    if (transformTree.size() < 2) {
-        transformTree.Insert(cc::TransformNode(), kRealRootNodeId);
-        cc::TransformNode& transformNode = *transformTree.back();
-        transformTree.SetTargetId(transformNode.id, kRealRootNodeId);
-        transformTree.SetContentTargetId(transformNode.id, kSecondaryRootNodeId);
-        transformNode.data.source_node_id = kRealRootNodeId;
-        transformNode.data.needs_local_transform_update = true;
-        transformNode.owner_id = ownerId;
-        transformTree.set_needs_update(true);
-    }
-    DCHECK_EQ(transformTree.size(), 2u);
+    transformTree.clear();
+    transformTree.Insert(cc::TransformNode(), kRealRootNodeId);
+    cc::TransformNode& transformNode = *transformTree.back();
+    transformTree.SetTargetId(transformNode.id, kRealRootNodeId);
+    transformTree.SetContentTargetId(transformNode.id, kSecondaryRootNodeId);
+    transformNode.data.source_node_id = kRealRootNodeId;
+    transformNode.data.needs_local_transform_update = true;
+    transformNode.owner_id = ownerId;
+    transformTree.set_needs_update(true);
 
     cc::ClipTree& clipTree = propertyTrees->clip_tree;
-    if (clipTree.size() < 2) {
-        clipTree.Insert(cc::ClipNode(), kRealRootNodeId);
-        cc::ClipNode& clipNode = *clipTree.back();
-        clipNode.data.transform_id = kSecondaryRootNodeId;
-        clipNode.data.target_id = kSecondaryRootNodeId;
-        clipNode.owner_id = ownerId;
-        clipTree.set_needs_update(true);
-    }
-    DCHECK_EQ(clipTree.size(), 2u);
+    clipTree.clear();
+    clipTree.Insert(cc::ClipNode(), kRealRootNodeId);
+    cc::ClipNode& clipNode = *clipTree.back();
+    clipNode.data.transform_id = kSecondaryRootNodeId;
+    clipNode.data.target_id = kSecondaryRootNodeId;
+    clipNode.owner_id = ownerId;
+    clipTree.set_needs_update(true);
 
     cc::EffectTree& effectTree = propertyTrees->effect_tree;
-    if (effectTree.size() < 2) {
-        // This matches what cc does right now: the secondary root isn't a child
-        // of the first root (at index 0). This may not have been intentional.
-        effectTree.Insert(cc::EffectNode(), kInvalidNodeId);
-        cc::EffectNode& effectNode = *effectTree.back();
-        effectNode.data.has_render_surface = true;
-        effectNode.data.transform_id = kRealRootNodeId;
-        effectNode.data.clip_id = kRealRootNodeId;
-        effectNode.owner_id = ownerId;
-        effectTree.set_needs_update(true);
-    }
-    DCHECK_EQ(effectTree.size(), 2u);
+    effectTree.clear();
+    // This matches what cc does right now: the secondary root isn't a child
+    // of the first root (at index 0). This may not have been intentional.
+    effectTree.Insert(cc::EffectNode(), kInvalidNodeId);
+    cc::EffectNode& effectNode = *effectTree.back();
+    effectNode.data.has_render_surface = true;
+    effectNode.data.transform_id = kRealRootNodeId;
+    effectNode.data.clip_id = kRealRootNodeId;
+    effectNode.owner_id = ownerId;
+    effectTree.set_needs_update(true);
 
     cc::ScrollTree& scrollTree = propertyTrees->scroll_tree;
-    if (scrollTree.size() < 2) {
-        scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId);
-        cc::ScrollNode& scrollNode = *scrollTree.back();
-        scrollNode.data.scrollable = false;
-        scrollNode.data.transform_id = kSecondaryRootNodeId;
-        scrollNode.owner_id = ownerId;
-        scrollTree.set_needs_update(true);
-    }
-    DCHECK_EQ(scrollTree.size(), 2u);
+    scrollTree.clear();
+    scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId);
+    cc::ScrollNode& scrollNode = *scrollTree.back();
+    scrollNode.data.scrollable = false;
+    scrollNode.data.transform_id = kSecondaryRootNodeId;
+    scrollNode.owner_id = ownerId;
+    scrollTree.set_needs_update(true);
 }
 
 } // namespace
 
 void PaintArtifactCompositor::update(const PaintArtifact& paintArtifact)
 {
     DCHECK(m_rootLayer);
 
+    if (m_extraDataForTestingEnabled)
+        m_extraDataForTesting = wrapUnique(new ExtraDataForTesting);
+
     // If the compositor is configured to expect using flat layer lists plus
     // property trees, then we should provide that format.
     cc::LayerTreeHost* host = m_rootLayer->layer_tree_host();
     const bool useLayerLists = host && host->settings().use_layer_lists;
     if (useLayerLists) {
         updateInLayerListMode(paintArtifact);
         return;
     }
 
     // TODO(jbroman): This should be incremental.
@@ skipping 16 matching lines @@
         if (const auto* clip = paintChunk.properties.clip.get()) {
             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);
+
+        if (m_extraDataForTestingEnabled)
+            m_extraDataForTesting->contentLayers.append(layer);
     }
 }
 
 scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset)
 {
     DCHECK(paintChunk.size());
 
     // If the paint chunk is a foreign layer, just return that layer.
     if (scoped_refptr<cc::Layer> foreignLayer = foreignLayerForPaintChunk(paintArtifact, paintChunk, layerOffset))
         return foreignLayer;
 
     // The common case: create a layer for painted content.
     gfx::Rect combinedBounds = enclosingIntRect(paintChunk.bounds);
     scoped_refptr<cc::DisplayItemList> displayList = recordPaintChunk(paintArtifact, paintChunk, combinedBounds);
     std::unique_ptr<ContentLayerClientImpl> contentLayerClient = wrapUnique(
         new ContentLayerClientImpl(std::move(displayList), gfx::Rect(combinedBounds.size())));
 
     layerOffset = combinedBounds.OffsetFromOrigin();
     scoped_refptr<cc::PictureLayer> layer = cc::PictureLayer::Create(contentLayerClient.get());
     layer->SetBounds(combinedBounds.size());
     layer->SetIsDrawable(true);
     if (paintChunk.knownToBeOpaque)
         layer->SetContentsOpaque(true);
     m_contentLayerClients.append(std::move(contentLayerClient));
     return layer;
 }
 
+namespace {
+
+class TransformTreeManager {
+    WTF_MAKE_NONCOPYABLE(TransformTreeManager);
+public:
+    TransformTreeManager(cc::TransformTree& transformTree, cc::Layer* dummyTransformParent)
+        : m_transformTree(transformTree)
+        , m_dummyTransformParent(dummyTransformParent) {}
+
+    int compositorIdForNode(const TransformPaintPropertyNode*);
+
+private:
+    // Transform tree which should be updated by the manager.
+    cc::TransformTree& m_transformTree;
+
+    // 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_dummyTransformParent;

[trchen, 2016/06/27 21:39:19]

This made me thought it's some internal state to create a dummy tree. I think we
should just call it m_rootLayer. The dummy layer is only a temporary workaround,
and it is very unlikely we use any other layer to host the dummy layers. 

[jbroman, 2016/06/27 21:53:58]

OK, done. It doesn't have to be the root (we could have some single child of the
root to which we attach all the synthetic layers, for instance), but since it
is, that does seem reasonable.

+
+    // Map from Blink-side transform nodes to cc transform node indices.
+    HashMap<const TransformPaintPropertyNode*, int> m_nodeMap;
+};
+
+int TransformTreeManager::compositorIdForNode(const TransformPaintPropertyNode* transformNode)
+{
+    if (!transformNode)
+        return kSecondaryRootNodeId;
+
+    auto it = m_nodeMap.find(transformNode);
+    if (it != m_nodeMap.end())
+        return it->value;
+
+    scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
+    int parentId = compositorIdForNode(transformNode->parent());
+    int id = m_transformTree.Insert(cc::TransformNode(), parentId);
+
+    cc::TransformNode& compositorNode = *m_transformTree.Node(id);
+    m_transformTree.SetTargetId(id, kSecondaryRootNodeId);
+    m_transformTree.SetContentTargetId(id, kSecondaryRootNodeId);
+    compositorNode.owner_id = dummyLayer->id();
+    compositorNode.data.source_node_id = parentId;
+    compositorNode.data.needs_local_transform_update = true;
+
+    FloatPoint3D origin = transformNode->origin();
+    compositorNode.data.pre_local.matrix().setTranslate(
+        -origin.x(), -origin.y(), -origin.z());
+    compositorNode.data.local.matrix() = TransformationMatrix::toSkMatrix44(transformNode->matrix());
+    compositorNode.data.post_local.matrix().setTranslate(
+        origin.x(), origin.y(), origin.z());
+    compositorNode.data.needs_local_transform_update = true;
+
+    m_dummyTransformParent->AddChild(dummyLayer);
+    dummyLayer->SetTransformTreeIndex(id);
+    dummyLayer->SetClipTreeIndex(kSecondaryRootNodeId);
+    dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
+    dummyLayer->SetScrollTreeIndex(kSecondaryRootNodeId);
+    dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
+
+    auto result = m_nodeMap.set(transformNode, id);
+    DCHECK(result.isNewEntry);
+    m_transformTree.set_needs_update(true);
+    return id;
+}
+
+} // namespace
+
 void PaintArtifactCompositor::updateInLayerListMode(const PaintArtifact& paintArtifact)
 {
     cc::LayerTreeHost* host = m_rootLayer->layer_tree_host();
 
     // The root layer must be the owner so that the render surface
     // validation works. It's expected to own at least the effect node.
     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(kSecondaryRootNodeId);
 
+    TransformTreeManager transformTreeManager(host->property_trees()->transform_tree, 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);
-        // This is only good enough to get trivial 2D translations working.
-        // We'll need to actually create more cc transform nodes to do any
-        // more; then we'll express offset-to-transform-parent relative to
-        // that transform node.
-        // TODO(jbroman): ^ Do that.
-        layer->set_offset_to_transform_parent(
-            transformToTransformSpace(paintChunk.properties.transform.get(), nullptr).To2dTranslation()
-            + layerOffset);
+
+        int transformId = transformTreeManager.compositorIdForNode(paintChunk.properties.transform.get());
+        layer->set_offset_to_transform_parent(layerOffset);
 
         m_rootLayer->AddChild(layer);
         layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
-        layer->SetTransformTreeIndex(kSecondaryRootNodeId);
+        layer->SetTransformTreeIndex(transformId);
         layer->SetClipTreeIndex(kSecondaryRootNodeId);
         layer->SetEffectTreeIndex(kSecondaryRootNodeId);
         layer->SetScrollTreeIndex(kSecondaryRootNodeId);
+
+        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