[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* rootLayer)
+        : m_transformTree(transformTree)
+        , m_rootLayer(rootLayer) {}
+
+    int compositorIdForNode(const TransformPaintPropertyNode*);

[pdr., 2016/06/27 23:09:23]

WDYT about making the compositor ids an internal implementation detail of this
class?

So, instead of:
void PaintArtifactCompositor::updateInLayerListMode(...) {
    int transformId =
transformTreeManager.compositorIdForNode(paintChunk.properties.transform.get());
    ...
    layer->SetTransformTreeIndex(transformId);

You'd do something like:
void PaintArtifactCompositor::updateInLayerListMode(...) {
   
transformTreeManager.updateTransformLayerCompositorId(paintChunk.properties.transform.get(),
layer);

+
+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_rootLayer;
+
+    // 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_rootLayer->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