Convert some LayerTreeHostCommon* tests to layer list mode

They are first converted with a script in
https://chromium-review.googlesource.com/c/chromium/src/+/1772308,
then checked, tested and modified manually.

Make layer list mode the default mode for LayerTreeHostCommonTest.

Tests still in layer tree mode are under
LayerTreeHostCommonTestWithLayerTree. Some tests can't be converted
into layer list mode because:
- They are testing features that for ui compositor;
- They are testing PropertyTreeBuilder; or

Also haven't converted tests that create layer tree in main-side,
and build property trees with the main-side PropertyTreeBuilder.

The tests still in layer tree mode using impl-side PropertyTreeBuilder
will be converted to use main-side PropertyTreeBuilder.

109 of 167 tests have been converted.

Bug: 994361
Change-Id: I04444c861c6f0e8aefa71b6cff2879b54429bc1e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1775746Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#691785}

cc/layers/layer_impl.h

@@ -89,7 +89,7 @@ class CC_EXPORT LayerImpl {
   bool IsActive() const;
 
   void SetHasTransformNode(bool val) { has_transform_node_ = val; }
-  bool has_transform_node() { return has_transform_node_; }
+  bool has_transform_node() const { return has_transform_node_; }
 
   void set_property_tree_sequence_number(int sequence_number) {}
 

cc/test/layer_test_common.cc

@@ -172,6 +172,14 @@ LayerTestCommon::LayerImplTest::~LayerImplTest() {
   host_->host_impl()->ReleaseLayerTreeFrameSink();
 }
 
+LayerImpl* LayerTestCommon::LayerImplTest::EnsureRootLayerInPendingTree() {
+  LayerTreeImpl* pending_tree = host_impl()->pending_tree();
+  if (LayerImpl* root = pending_tree->root_layer_for_testing())
+    return root;
+  pending_tree->SetRootLayerForTesting(LayerImpl::Create(pending_tree, 1));
+  return pending_tree->root_layer_for_testing();
+}
+
 void LayerTestCommon::LayerImplTest::CalcDrawProps(
     const gfx::Size& viewport_size) {
   RenderSurfaceList render_surface_list;

cc/test/layer_test_common.h

@@ -82,103 +82,45 @@ class LayerTestCommon {
                   std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink);
     ~LayerImplTest();
 
-    template <typename T>
-    T* AddChildToRoot() {
-      std::unique_ptr<T> layer =
-          T::Create(host_->host_impl()->active_tree(), layer_impl_id_++);
-      T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
-      return ptr;
+    template <typename T, typename... Args>
+    T* AddLayer(Args&&... args) {
+      return AddLayerInternal<T>(host_impl()->active_tree(),
+                                 std::forward<Args>(args)...);
     }
 
-    template <typename T>
-    T* AddChild(LayerImpl* parent) {
-      std::unique_ptr<T> layer =
-          T::Create(host_->host_impl()->active_tree(), layer_impl_id_++);
-      T* ptr = layer.get();
-      parent->test_properties()->AddChild(std::move(layer));
-      return ptr;
-    }
+    LayerImpl* EnsureRootLayerInPendingTree();
 
-    template <typename T>
-    T* AddMaskLayer(LayerImpl* origin) {
-      std::unique_ptr<T> layer =
-          T::Create(host_->host_impl()->active_tree(), layer_impl_id_++);
-      T* ptr = layer.get();
-      origin->test_properties()->SetMaskLayer(std::move(layer));
-      return ptr;
+    template <typename T, typename... Args>
+    T* AddLayerInPendingTree(Args&&... args) {
+      return AddLayerInternal<T>(host_impl()->pending_tree(),
+                                 std::forward<Args>(args)...);
     }
 
-    template <typename T, typename A>
-    T* AddChildToRoot(const A& a) {
-      std::unique_ptr<T> layer =
-          T::Create(host_->host_impl()->active_tree(), layer_impl_id_++, a);
-      T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
-      return ptr;
+    // TODO(crbug.com/994361): Remove this function when all impl-side tests are
+    // converted into layer list mode.
+    template <typename T, typename... Args>
+    T* AddChildToRoot(Args&&... args) {
+      return AddLayer<T>(std::forward<Args>(args)...);
     }
 
-    template <typename T, typename A, typename B>
-    T* AddChildToRoot(const A& a, const B& b) {
+    // TODO(crbug.com/994361): Remove this function when all impl-side tests are
+    // converted into layer list mode.
+    template <typename T, typename... Args>
+    T* AddChild(LayerImpl* parent, Args&&... args) {
       std::unique_ptr<T> layer =
-          T::Create(host_->host_impl()->active_tree(), layer_impl_id_++, a, b);
-      T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
-      return ptr;
-    }
-
-    template <typename T, typename A, typename B, typename C>
-    T* AddChildToRoot(const A& a, const B& b, const C& c) {
-      std::unique_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
-                                           layer_impl_id_++, a, b, c);
-      T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
-      return ptr;
-    }
-
-    template <typename T, typename A, typename B, typename C, typename D>
-    T* AddChildToRoot(const A& a, const B& b, const C& c, const D& d) {
-      std::unique_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
-                                           layer_impl_id_++, a, b, c, d);
+          T::Create(host_impl()->active_tree(), layer_impl_id_++,
+                    std::forward<Args>(args)...);
       T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
-      return ptr;
-    }
-
-    template <typename T,
-              typename A,
-              typename B,
-              typename C,
-              typename D,
-              typename E>
-    T* AddChildToRoot(const A& a,
-                      const B& b,
-                      const C& c,
-                      const D& d,
-                      const E& e) {
-      std::unique_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
-                                           layer_impl_id_++, a, b, c, d, e);
-      T* ptr = layer.get();
-      root_layer_for_testing()->test_properties()->AddChild(std::move(layer));
+      parent->test_properties()->AddChild(std::move(layer));
       return ptr;
     }
 
-    template <typename T,
-              typename A,
-              typename B,
-              typename C,
-              typename D,
-              typename E>
-    T* AddChild(LayerImpl* parent,
-                const A& a,
-                const B& b,
-                const C& c,
-                const D& d,
-                const E& e) {
-      std::unique_ptr<T> layer = T::Create(host_->host_impl()->active_tree(),
-                                           layer_impl_id_++, a, b, c, d, e);
+    template <typename T>
+    T* AddMaskLayer(LayerImpl* origin) {
+      std::unique_ptr<T> layer =
+          T::Create(host_impl()->active_tree(), layer_impl_id_++);
       T* ptr = layer.get();
-      parent->test_properties()->AddChild(std::move(layer));
+      origin->test_properties()->SetMaskLayer(std::move(layer));
       return ptr;
     }
 
@@ -260,6 +202,16 @@ class LayerTestCommon {
     }
 
    private:
+    template <typename T, typename... Args>
+    T* AddLayerInternal(LayerTreeImpl* tree, Args&&... args) {
+      std::unique_ptr<T> layer =
+          T::Create(tree, layer_impl_id_++, std::forward<Args>(args)...);
+      T* ptr = layer.get();
+      tree->root_layer_for_testing()->test_properties()->AddChild(
+          std::move(layer));
+      return ptr;
+    }
+
     FakeLayerTreeHostClient client_;
     TestTaskGraphRunner task_graph_runner_;
     std::unique_ptr<LayerTreeFrameSink> layer_tree_frame_sink_;

cc/test/property_tree_test_utils.cc

@@ -23,6 +23,7 @@ template <typename LayerType>
 void SetupRootPropertiesInternal(LayerType* root) {
   root->set_property_tree_sequence_number(
       GetPropertyTrees(root)->sequence_number);
+  root->SetElementId(LayerIdToElementIdForTesting(root->id()));
 
   auto& root_transform_node =
       CreateTransformNode(root, TransformTree::kRootNodeId);
@@ -31,10 +32,16 @@ void SetupRootPropertiesInternal(LayerType* root) {
   auto& root_clip_node = CreateClipNode(root, ClipTree::kRootNodeId);
   DCHECK_EQ(root_clip_node.id, ClipTree::kViewportNodeId);
   root_clip_node.clip = gfx::RectF(gfx::SizeF(root->bounds()));
+  // Root clip is in the real root transform space instead of the root layer's
+  // transform space.
+  root_clip_node.transform_id = TransformTree::kRootNodeId;
 
   auto& root_effect_node = CreateEffectNode(root, EffectTree::kRootNodeId);
   DCHECK_EQ(root_effect_node.id, EffectTree::kContentsRootNodeId);
   root_effect_node.render_surface_reason = RenderSurfaceReason::kRoot;
+  // Root effect is in the real root transform space instead of the root layer's
+  // transform space.
+  root_effect_node.transform_id = TransformTree::kRootNodeId;
 
   auto& root_scroll_node = CreateScrollNode(root, ScrollTree::kRootNodeId);
   DCHECK_EQ(root_scroll_node.id, ScrollTree::kSecondaryRootNodeId);
@@ -66,6 +73,10 @@ TransformNode& CreateTransformNodeInternal(LayerType* layer, int parent_id) {
     property_trees->element_id_to_transform_node_index[node->element_id] =
         node->id;
   }
+  if (const auto* parent_node = transform_tree.Node(node->parent_id)) {
+    node->in_subtree_of_page_scale_layer =
+        parent_node->in_subtree_of_page_scale_layer;
+  }
   transform_tree.set_needs_update(true);
   return *node;
 }
@@ -137,10 +148,10 @@ ScrollNode& CreateScrollNodeInternal(LayerType* layer, int parent_id) {
 template <typename LayerType>
 void SetScrollOffsetInternal(LayerType* layer,
                              const gfx::ScrollOffset& scroll_offset) {
+  DCHECK(layer->has_transform_node());
   auto* transform_node = GetTransformNode(layer);
   transform_node->scroll_offset = scroll_offset;
-  transform_node->needs_local_transform_update = true;
-  GetPropertyTrees(layer)->transform_tree.set_needs_update(true);
+  SetLocalTransformChanged(layer);
   GetPropertyTrees(layer)->scroll_tree.SetScrollOffset(layer->element_id(),
                                                        scroll_offset);
 }
@@ -250,7 +261,8 @@ void SetupViewport(Layer* root,
                    overscroll_elasticity_layer.get());
     CreateTransformNode(overscroll_elasticity_layer.get());
     CopyProperties(overscroll_elasticity_layer.get(), page_scale_layer.get());
-    CreateTransformNode(page_scale_layer.get());
+    CreateTransformNode(page_scale_layer.get()).in_subtree_of_page_scale_layer =
+        true;
     CopyProperties(page_scale_layer.get(), inner_viewport_scroll_layer.get());
     CreateTransformNode(inner_viewport_scroll_layer.get());
     CreateScrollNode(inner_viewport_scroll_layer.get());

cc/test/property_tree_test_utils.h

@@ -50,27 +50,73 @@ ScrollNode& CreateScrollNode(Layer*,
 ScrollNode& CreateScrollNode(LayerImpl*,
                              int parent_id = ScrollTree::kInvalidNodeId);
 
-void SetScrollOffset(Layer*, const gfx::ScrollOffset&);
-void SetScrollOffset(LayerImpl*, const gfx::ScrollOffset&);
-
 template <typename LayerType>
-TransformNode* GetTransformNode(LayerType* layer) {
+TransformNode* GetTransformNode(const LayerType* layer) {
   return GetPropertyTrees(layer)->transform_tree.Node(
       layer->transform_tree_index());
 }
 template <typename LayerType>
-ClipNode* GetClipNode(LayerType* layer) {
+ClipNode* GetClipNode(const LayerType* layer) {
   return GetPropertyTrees(layer)->clip_tree.Node(layer->clip_tree_index());
 }
 template <typename LayerType>
-EffectNode* GetEffectNode(LayerType* layer) {
+EffectNode* GetEffectNode(const LayerType* layer) {
   return GetPropertyTrees(layer)->effect_tree.Node(layer->effect_tree_index());
 }
 template <typename LayerType>
-ScrollNode* GetScrollNode(LayerType* layer) {
+ScrollNode* GetScrollNode(const LayerType* layer) {
   return GetPropertyTrees(layer)->scroll_tree.Node(layer->scroll_tree_index());
 }
 
+void SetScrollOffset(Layer*, const gfx::ScrollOffset&);
+void SetScrollOffset(LayerImpl*, const gfx::ScrollOffset&);
+
+template <typename LayerType>
+void SetLocalTransformChanged(const LayerType* layer) {
+  DCHECK(layer->has_transform_node());
+  auto* transform_node = GetTransformNode(layer);
+  transform_node->needs_local_transform_update = true;
+  transform_node->transform_changed = true;
+  GetPropertyTrees(layer)->transform_tree.set_needs_update(true);
+}
+
+template <typename LayerType>
+void SetTransform(const LayerType* layer, const gfx::Transform& transform) {
+  GetTransformNode(layer)->local = transform;
+  SetLocalTransformChanged(layer);
+}
+
+template <typename LayerType>
+void SetTransformOrigin(const LayerType* layer, const gfx::Point3F& origin) {
+  GetTransformNode(layer)->origin = origin;
+  SetLocalTransformChanged(layer);
+}
+
+template <typename LayerType>
+void SetPostTranslation(const LayerType* layer,
+                        const gfx::Vector2dF& post_translation) {
+  GetTransformNode(layer)->post_translation = post_translation;
+  SetLocalTransformChanged(layer);
+}
+
+// This will affect all layers associated with this layer's effect node.
+template <typename LayerType>
+void SetOpacity(const LayerType* layer, float opacity) {
+  auto* effect_node = GetEffectNode(layer);
+  effect_node->opacity = opacity;
+  effect_node->effect_changed = true;
+  GetPropertyTrees(layer)->effect_tree.set_needs_update(true);
+}
+
+// This will affect all layers associated with this layer's effect node.
+template <typename LayerType>
+void SetFilter(const LayerType* layer, const FilterOperations& filters) {
+  auto* effect_node = GetEffectNode(layer);
+  effect_node->filters = filters;
+  effect_node->effect_changed = true;
+  GetPropertyTrees(layer)->effect_tree.set_needs_update(true);
+}
+
 // Creates viewport layers and (in layer list mode) paint properties.
 // Convenient overload of the method below that creates a scrolling layer as
 // the outer viewport scroll layer.

cc/trees/layer_tree_host_common.cc

@@ -664,11 +664,11 @@ void LayerTreeHostCommon::CalculateDrawPropertiesForTesting(
                                               : DONT_BUILD_PROPERTY_TREES);
 }
 
-PropertyTrees* GetPropertyTrees(Layer* layer) {
+PropertyTrees* GetPropertyTrees(const Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
-PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
+PropertyTrees* GetPropertyTrees(const LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 

cc/trees/layer_tree_host_common.h

@@ -218,8 +218,8 @@ void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* tree_impl,
   }
 }
 
-CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer);
-CC_EXPORT PropertyTrees* GetPropertyTrees(LayerImpl* layer);
+CC_EXPORT PropertyTrees* GetPropertyTrees(const Layer* layer);
+CC_EXPORT PropertyTrees* GetPropertyTrees(const LayerImpl* layer);
 
 }  // namespace cc
 

cc/trees/property_tree.cc

@@ -584,6 +584,7 @@ void TransformTree::UpdateNodeAndAncestorsAreAnimatedOrInvertible(
 void TransformTree::SetRootScaleAndTransform(
     float device_scale_factor,
     const gfx::Transform& device_transform) {
+  device_scale_factor_ = device_scale_factor;
   gfx::Vector2dF device_transform_scale_components =
       MathUtil::ComputeTransform2dScaleComponents(device_transform, 1.f);