[compositor-worker] root scrolling layer is associated with document scrolling element

third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp

 // Copyright 2016 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/CompositorMutableState.h"
 
 #include "base/message_loop/message_loop.h"
 #include "cc/test/fake_compositor_frame_sink.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 61 matching lines @@
       LayerImpl::Create(hostImpl().active_tree(), 42);
   SetLayerPropertiesForTesting(root.get());
 
   hostImpl().SetViewportSize(root->bounds());
   hostImpl().active_tree()->SetRootLayerForTesting(std::move(root));
   hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   CompositorMutations mutations;
   CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
   std::unique_ptr<CompositorMutableState> state(
-      provider.getMutableStateFor(42));
+      provider.getMutableStateFor(42, 42));
   EXPECT_FALSE(state);
 }
 
 TEST_F(CompositorMutableStateTest, MutableStateMutableProperties) {
   // In this test, there is a layer with an element id and mutable properties.
   // In this case, we should get a valid mutable state for this element id that
   // has a real effect on the corresponding layer.
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(hostImpl().active_tree(), 42);
 
   std::unique_ptr<LayerImpl> scopedLayer =
       LayerImpl::Create(hostImpl().active_tree(), 11);
   LayerImpl* layer = scopedLayer.get();
   layer->SetScrollClipLayer(root->id());
 
   root->test_properties()->AddChild(std::move(scopedLayer));
 
   SetLayerPropertiesForTesting(layer);
 
-  int primaryId = 12;
+  int mainId = 12;
+  int scrollId = 13;

[flackr, 2017/03/01 16:31:26]

To be accurate to the real implementation, isn't the scrolling layer the outer
(root) layer?

+
   root->SetElementId(
-      createCompositorElementId(primaryId, CompositorSubElementId::Primary));
+      createCompositorElementId(mainId, CompositorSubElementId::Primary));
   layer->SetElementId(
-      createCompositorElementId(primaryId, CompositorSubElementId::Scroll));
+      createCompositorElementId(scrollId, CompositorSubElementId::Scroll));
 
   root->SetMutableProperties(CompositorMutableProperty::kOpacity |
                              CompositorMutableProperty::kTransform);
   layer->SetMutableProperties(CompositorMutableProperty::kScrollLeft |
                               CompositorMutableProperty::kScrollTop);
 
   hostImpl().SetViewportSize(layer->bounds());
   hostImpl().active_tree()->SetRootLayerForTesting(std::move(root));
   hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   CompositorMutations mutations;
   CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
 
   std::unique_ptr<CompositorMutableState> state(
-      provider.getMutableStateFor(primaryId));
+      provider.getMutableStateFor(mainId, scrollId));
   EXPECT_TRUE(state.get());
 
   EXPECT_EQ(1.0, rootLayer()->Opacity());
   EXPECT_EQ(gfx::Transform().ToString(), rootLayer()->Transform().ToString());
   EXPECT_EQ(0.0, layer->CurrentScrollOffset().x());
   EXPECT_EQ(0.0, layer->CurrentScrollOffset().y());
 
   gfx::Transform zero(0, 0, 0, 0, 0, 0);
   state->setOpacity(0.5);
   state->setTransform(zero.matrix());
   state->setScrollLeft(1.0);
   state->setScrollTop(1.0);
 
   EXPECT_EQ(0.5, rootLayer()->Opacity());
   EXPECT_EQ(zero.ToString(), rootLayer()->Transform().ToString());
   EXPECT_EQ(1.0, layer->CurrentScrollOffset().x());
   EXPECT_EQ(1.0, layer->CurrentScrollOffset().y());
 
   // The corresponding mutation should reflect the changed values.
   EXPECT_EQ(1ul, mutations.map.size());
 
-  const CompositorMutation& mutation = *mutations.map.find(primaryId)->value;
+  const CompositorMutation& mutation = *mutations.map.find(mainId)->value;
   EXPECT_TRUE(mutation.isOpacityMutated());
   EXPECT_TRUE(mutation.isTransformMutated());
   EXPECT_TRUE(mutation.isScrollLeftMutated());
   EXPECT_TRUE(mutation.isScrollTopMutated());
 
   EXPECT_EQ(0.5, mutation.opacity());
   EXPECT_EQ(zero.ToString(), gfx::Transform(mutation.transform()).ToString());
   EXPECT_EQ(1.0, mutation.scrollLeft());
   EXPECT_EQ(1.0, mutation.scrollTop());
 }
 
+TEST_F(CompositorMutableStateTest, MutableStateWithoutScrollLayer) {
+  // There is a main layer with an element id but there is not scroll layer with
+  // and element id. We should have a valid mutable state given but mutating its
+  // scroll properties should have no effect.
+  std::unique_ptr<LayerImpl> root =
+      LayerImpl::Create(hostImpl().active_tree(), 42);
+  SetLayerPropertiesForTesting(root.get());
+
+  root->SetElementId(
+      createCompositorElementId(42, CompositorSubElementId::Primary));
+
+  root->SetMutableProperties(CompositorMutableProperty::kOpacity |
+                             CompositorMutableProperty::kTransform);
+
+  hostImpl().SetViewportSize(root->bounds());
+  hostImpl().active_tree()->SetRootLayerForTesting(std::move(root));
+  hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
+
+  CompositorMutations mutations;
+  CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
+  std::unique_ptr<CompositorMutableState> state(
+      provider.getMutableStateFor(42, 42));
+
+  EXPECT_TRUE(state.get());
+  EXPECT_EQ(1.0, rootLayer()->Opacity());
+  EXPECT_EQ(0.0, rootLayer()->CurrentScrollOffset().x());
+  EXPECT_EQ(0.0, rootLayer()->CurrentScrollOffset().y());
+
+  state->setOpacity(0.5);
+  state->setScrollLeft(1.0);
+  state->setScrollTop(1.0);
+
+  EXPECT_EQ(1ul, mutations.map.size());
+
+  const CompositorMutation& mutation = *mutations.map.find(42)->value;
+  EXPECT_TRUE(mutation.isOpacityMutated());
+  EXPECT_FALSE(mutation.isScrollLeftMutated());
+  EXPECT_FALSE(mutation.isScrollTopMutated());
+
+  EXPECT_EQ(0.5, rootLayer()->Opacity());
+  EXPECT_EQ(0.0, rootLayer()->CurrentScrollOffset().x());
+  EXPECT_EQ(0.0, rootLayer()->CurrentScrollOffset().y());
+}
+
 }  // namespace blink