[compositor-worker] Create property tree nodes for proxies.

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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 "cc/trees/layer_tree_impl.h"
 
+#include "base/macros.h"
+#include "cc/animation/mutable_properties.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/layer_tree_settings_for_testing.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 1992 matching lines @@
   EXPECT_FALSE(output.start.visible());
 
   // If the handle bottom is partially visible, the handle is marked visible.
   input.start.edge_top = gfx::Point(0, -20);
   input.start.edge_bottom = gfx::Point(0, 1);
   host_impl().active_tree()->RegisterSelection(input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_TRUE(output.start.visible());
 }
 
+TEST_F(LayerTreeImplTest, NodesiesForProxies) {
+  LayerImpl* root = root_layer();
+  root->SetDrawsContent(true);
+  root->SetBounds(gfx::Size(100, 100));
+
+  uint32_t properties[] = {
+      MutableProperty::kOpacity, MutableProperty::kScrollLeft,
+      MutableProperty::kScrollTop, MutableProperty::kTransform,
+  };
+
+  for (size_t i = 0; i < arraysize(properties); ++i) {
+    int sub_layer_id = i + 2;
+    std::unique_ptr<LayerImpl> sub_layer =
+        LayerImpl::Create(host_impl().active_tree(), sub_layer_id);
+    sub_layer->SetBounds(gfx::Size(50, 50));
+    sub_layer->SetDrawsContent(true);
+    sub_layer->SetMutableProperties(properties[i]);
+    root->test_properties()->AddChild(std::move(sub_layer));
+  }
+
+  host_impl().active_tree()->BuildPropertyTreesForTesting();
+
+  for (size_t i = 0; i < arraysize(properties); ++i) {
+    LayerImpl* layer = host_impl().active_tree()->LayerById(i + 2);
+    switch (properties[i]) {
+      case MutableProperty::kOpacity:
+        DCHECK_EQ(root->transform_tree_index(), layer->transform_tree_index());
+        DCHECK_NE(root->effect_tree_index(), layer->effect_tree_index());
+        break;
+      case MutableProperty::kScrollLeft:
+      case MutableProperty::kScrollTop:
+      case MutableProperty::kTransform:
+        DCHECK_EQ(root->effect_tree_index(), layer->effect_tree_index());
+        DCHECK_NE(root->transform_tree_index(), layer->transform_tree_index());
+        for (size_t j = 0; j < arraysize(properties); ++j) {
+          if (j == i)
+            continue;
+          LayerImpl* other = host_impl().active_tree()->LayerById(j + 2);
+          DCHECK_NE(other->transform_tree_index(),
+                    layer->transform_tree_index());
+        }
+        break;
+    }
+  }
+}
+
 TEST_F(LayerTreeImplTest, SelectionBoundsForScaledLayers) {
   LayerImpl* root = root_layer();
   root->SetDrawsContent(true);
   root->SetBounds(gfx::Size(100, 100));
 
   int root_layer_id = root->id();
   int sub_layer_id = 2;
 
   gfx::Vector2dF sub_layer_offset(10, 0);
   {
@@ skipping 293 matching lines @@
     auto weak_promise = promise->AsWeakPtr();
     host_impl().active_tree()->QueueSwapPromise(std::move(promise));
     host_impl().active_tree()->BreakSwapPromises(
         SwapPromise::DidNotSwapReason::SWAP_FAILS);
     EXPECT_FALSE(weak_promise);
   }
 }
 
 }  // namespace
 }  // namespace cc