Remove scroll_clip_layer dependency from LayerTreeImpl::ScrollableSize

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 5688 matching lines @@
   // Tear down the LayerTreeHostImpl before the InputHandlerClient.
   host_impl_->ReleaseCompositorFrameSink();
   host_impl_ = nullptr;
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(20, 20);
   gfx::Size viewport_size(10, 10);
+  const int kPageScaleLayerId = 1;
+  const int kViewportClipLayerId = 2;
+  const int kViewportScrollLayerId = 3;
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      LayerImpl::Create(host_impl_->active_tree(), kPageScaleLayerId);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 2);
+      LayerImpl::Create(host_impl_->active_tree(), kViewportClipLayerId);
   root_clip->test_properties()->force_render_surface = true;
-  std::unique_ptr<LayerImpl> root_scrolling =
-      CreateScrollableLayer(3, surface_size, root_clip.get());
+  std::unique_ptr<LayerImpl> root_scrolling = CreateScrollableLayer(
+      kViewportScrollLayerId, surface_size, root_clip.get());
   root_scrolling->test_properties()->is_container_for_fixed_position_layers =
       true;
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(5, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(4, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->test_properties()->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
   root_scrolling->test_properties()->AddChild(std::move(child));
   root_clip->test_properties()->AddChild(std::move(root_scrolling));
   EXPECT_EQ(viewport_size, root_clip->bounds());
   root_ptr->test_properties()->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_ptr));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, 1, Layer::INVALID_ID, Layer::INVALID_ID, 3,
-      Layer::INVALID_ID);
+      Layer::INVALID_ID, kPageScaleLayerId, kViewportClipLayerId,
+      Layer::INVALID_ID, kViewportScrollLayerId, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(viewport_size);
 
   grand_child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
                                                      gfx::ScrollOffset(0, 2));
   child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
@@ skipping 98 matching lines @@
     // Should have scrolled by half the amount in layer space (5 - 2/2)
     EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), grand_child->id(),
                                    gfx::Vector2d(0, 4)));
   }
 }
 TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
+  const int kPageScaleLayerId = 4;
+  const int kViewportClipLayerId = 1;
+  const int kViewportScrollLayerId = 2;
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      LayerImpl::Create(host_impl_->active_tree(), kPageScaleLayerId);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
-  std::unique_ptr<LayerImpl> root_scroll =
-      CreateScrollableLayer(1, content_size, root_clip.get());
+  std::unique_ptr<LayerImpl> root_scroll = CreateScrollableLayer(
+      kViewportClipLayerId, content_size, root_clip.get());
   // Make 'root' the clip layer for child: since they have the same sizes the
   // child will have zero max_scroll_offset and scrolls will bubble.
-  std::unique_ptr<LayerImpl> child =
-      CreateScrollableLayer(2, content_size, root_scroll.get());
+  std::unique_ptr<LayerImpl> child = CreateScrollableLayer(
+      kViewportScrollLayerId, content_size, root_scroll.get());
   child->test_properties()->is_container_for_fixed_position_layers = true;
   root_scroll->SetBounds(content_size);
 
   int root_scroll_id = root_scroll->id();
   root_scroll->test_properties()->AddChild(std::move(child));
   root_clip->test_properties()->AddChild(std::move(root_scroll));
   root_ptr->test_properties()->AddChild(std::move(root_clip));
 
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, 4, Layer::INVALID_ID, Layer::INVALID_ID, 2,
-      Layer::INVALID_ID);
+      Layer::INVALID_ID, kPageScaleLayerId, kViewportClipLayerId,
+      Layer::INVALID_ID, kViewportScrollLayerId, Layer::INVALID_ID);
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_
                   ->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                 InputHandler::WHEEL)
                   .thread);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
     host_impl_->ScrollEnd(EndState().get());
 
     std::unique_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the root scroll should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
     EXPECT_TRUE(
         ScrollInfoContains(*scroll_info.get(), root_scroll_id, scroll_delta));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
+  const int kPageScaleLayerId = 1;
+  const int kInnerViewportClipLayerId = 2;
+  const int kOuterViewportClipLayerId = 7;
+  const int kInnerViewportScrollLayerId = 3;
+  const int kOuterViewportScrollLayerId = 8;
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+      LayerImpl::Create(host_impl_->active_tree(), kPageScaleLayerId);
   std::unique_ptr<LayerImpl> inner_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 2);
-  std::unique_ptr<LayerImpl> inner_scroll =
-      CreateScrollableLayer(3, surface_size, inner_clip.get());
+      LayerImpl::Create(host_impl_->active_tree(), kInnerViewportClipLayerId);
+  std::unique_ptr<LayerImpl> inner_scroll = CreateScrollableLayer(
+      kInnerViewportScrollLayerId, surface_size, inner_clip.get());
   std::unique_ptr<LayerImpl> outer_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 7);
-  std::unique_ptr<LayerImpl> outer_scroll =
-      CreateScrollableLayer(8, surface_size, outer_clip.get());
+      LayerImpl::Create(host_impl_->active_tree(), kOuterViewportClipLayerId);
+  std::unique_ptr<LayerImpl> outer_scroll = CreateScrollableLayer(
+      kOuterViewportScrollLayerId, surface_size, outer_clip.get());
   inner_clip->test_properties()->force_render_surface = true;
   inner_scroll->test_properties()->is_container_for_fixed_position_layers =
       true;
   outer_scroll->test_properties()->is_container_for_fixed_position_layers =
       true;
   outer_clip->test_properties()->AddChild(std::move(outer_scroll));
   inner_scroll->test_properties()->AddChild(std::move(outer_clip));
   inner_clip->test_properties()->AddChild(std::move(inner_scroll));
   root_ptr->test_properties()->AddChild(std::move(inner_clip));
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, 1, Layer::INVALID_ID, Layer::INVALID_ID, 3, 8);
+      Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportClipLayerId,
+      kOuterViewportClipLayerId, kInnerViewportScrollLayerId,
+      kOuterViewportScrollLayerId);
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   DrawFrame();
 
+  const int kPageScaleLayerId2 = 4;
+  const int kInnerViewportClipLayerId2 = 5;
+  const int kOuterViewportClipLayerId2 = 9;
+  const int kInnerViewportScrollLayerId2 = 6;
+  const int kOuterViewportScrollLayerId2 = 10;
   host_impl_->active_tree()->DetachLayers();
   std::unique_ptr<LayerImpl> root_ptr2 =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> inner_clip2 =
-      LayerImpl::Create(host_impl_->active_tree(), 5);
-  std::unique_ptr<LayerImpl> inner_scroll2 =
-      CreateScrollableLayer(6, surface_size, inner_clip2.get());
+      LayerImpl::Create(host_impl_->active_tree(), kInnerViewportClipLayerId2);
+  std::unique_ptr<LayerImpl> inner_scroll2 = CreateScrollableLayer(
+      kInnerViewportScrollLayerId2, surface_size, inner_clip2.get());
   std::unique_ptr<LayerImpl> outer_clip2 =
-      LayerImpl::Create(host_impl_->active_tree(), 9);
-  std::unique_ptr<LayerImpl> outer_scroll2 =
-      CreateScrollableLayer(10, surface_size, outer_clip2.get());
+      LayerImpl::Create(host_impl_->active_tree(), kOuterViewportClipLayerId2);
+  std::unique_ptr<LayerImpl> outer_scroll2 = CreateScrollableLayer(
+      kOuterViewportScrollLayerId2, surface_size, outer_clip2.get());
   inner_scroll2->test_properties()->is_container_for_fixed_position_layers =
       true;
   outer_scroll2->test_properties()->is_container_for_fixed_position_layers =
       true;
   outer_clip2->test_properties()->AddChild(std::move(outer_scroll2));
   inner_scroll2->test_properties()->AddChild(std::move(outer_clip2));
   inner_clip2->test_properties()->AddChild(std::move(inner_scroll2));
   inner_clip2->test_properties()->force_render_surface = true;
   root_ptr2->test_properties()->AddChild(std::move(inner_clip2));
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_ptr2));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, 4, Layer::INVALID_ID, Layer::INVALID_ID, 6, 10);
+      Layer::INVALID_ID, kPageScaleLayerId2, kInnerViewportClipLayerId2,
+      kOuterViewportClipLayerId2, kInnerViewportScrollLayerId2,
+      kOuterViewportScrollLayerId2);
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   EXPECT_EQ(
       InputHandler::SCROLL_ON_IMPL_THREAD,
       host_impl_
           ->ScrollBegin(BeginState(gfx::Point(5, 5)).get(), InputHandler::WHEEL)
           .thread);
 }
 
@@ skipping 546 matching lines @@
             host_impl_->accumulated_root_overscroll());
 
   host_impl_->ScrollEnd(EndState().get());
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) {
   // Scroll child layers beyond their maximum scroll range and make sure root
   // overscroll does not accumulate.
   InputHandlerScrollResult scroll_result;
   gfx::Size surface_size(10, 10);
+  const int kInnerViewportClipLayerId = 4;
+  const int kInnerViewportScrollLayerId = 1;
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      LayerImpl::Create(host_impl_->active_tree(), kInnerViewportClipLayerId);
   root_clip->test_properties()->force_render_surface = true;
 
-  std::unique_ptr<LayerImpl> root =
-      CreateScrollableLayer(1, surface_size, root_clip.get());
+  std::unique_ptr<LayerImpl> root = CreateScrollableLayer(
+      kInnerViewportScrollLayerId, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->test_properties()->AddChild(std::move(grand_child));
 
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, Layer::INVALID_ID, Layer::INVALID_ID,
-      Layer::INVALID_ID, root->id(), Layer::INVALID_ID);
+      Layer::INVALID_ID, Layer::INVALID_ID, kInnerViewportClipLayerId,
+      Layer::INVALID_ID, kInnerViewportScrollLayerId, Layer::INVALID_ID);
 
   LayerImpl* child_layer = child.get();
   root->test_properties()->AddChild(std::move(child));
   root_clip->test_properties()->AddChild(std::move(root));
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_clip));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
   child_layer->layer_tree_impl()
       ->property_trees()
@@ skipping 2274 matching lines @@
   // released, and the texture deleted.
   EXPECT_TRUE(context_provider->HasOneRef());
   EXPECT_EQ(0u, context_provider->TestContext3d()->NumTextures());
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldNotBubble) {
   // When flinging via touch, only the child should scroll (we should not
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
+  const int kPageScaleLayerId = 4;
+  const int kInnerViewportClipLayerId = 3;
+  const int kInnerViewportScrollLayerId = 1;
   std::unique_ptr<LayerImpl> root_ptr =
-      LayerImpl::Create(host_impl_->active_tree(), 4);
+      LayerImpl::Create(host_impl_->active_tree(), kPageScaleLayerId);
   std::unique_ptr<LayerImpl> root_clip =
-      LayerImpl::Create(host_impl_->active_tree(), 3);
+      LayerImpl::Create(host_impl_->active_tree(), kInnerViewportClipLayerId);
   root_clip->test_properties()->force_render_surface = true;
 
-  std::unique_ptr<LayerImpl> root_scroll =
-      CreateScrollableLayer(1, content_size, root_clip.get());
+  std::unique_ptr<LayerImpl> root_scroll = CreateScrollableLayer(
+      kInnerViewportScrollLayerId, content_size, root_clip.get());
   root_scroll->test_properties()->is_container_for_fixed_position_layers = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
   root_scroll->test_properties()->AddChild(std::move(child));
   int root_id = root_scroll->id();
   root_clip->test_properties()->AddChild(std::move(root_scroll));
   root_ptr->test_properties()->AddChild(std::move(root_clip));
 
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, 4, Layer::INVALID_ID, Layer::INVALID_ID, 1,
-      Layer::INVALID_ID);
+      Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportClipLayerId,
+      Layer::INVALID_ID, kInnerViewportScrollLayerId, Layer::INVALID_ID);
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_
                   ->ScrollBegin(BeginState(gfx::Point()).get(),
                                 InputHandler::TOUCHSCREEN)
                   .thread);
 
@@ skipping 986 matching lines @@
   const gfx::Size root_layer_size(200, 200);
   const gfx::Size viewport_size(100, 100);
 
   SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       viewport_size, viewport_size, root_layer_size);
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
   LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
   LayerImpl* scroll_layer = nullptr;
+  LayerImpl* clip_layer = nullptr;
 
   // Initialization: Add a child scrolling layer to the outer scroll layer and
   // set its scroll layer as the outer viewport. This simulates setting a
   // scrolling element as the root scroller on the page.
   {
     std::unique_ptr<LayerImpl> clip = LayerImpl::Create(layer_tree_impl, 10);
     clip->SetBounds(root_layer_size);
     clip->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> scroll = LayerImpl::Create(layer_tree_impl, 11);
     scroll->SetBounds(scroll_content_size);
     scroll->SetScrollClipLayer(clip->id());
     scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
     scroll->SetDrawsContent(true);
 
     scroll_layer = scroll.get();
+    clip_layer = clip.get();
 
     clip->test_properties()->AddChild(std::move(scroll));
     outer_scroll->test_properties()->AddChild(std::move(clip));
-
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, layer_tree_impl->PageScaleLayer()->id(),
-        Layer::INVALID_ID, Layer::INVALID_ID, inner_scroll->id(),
-        scroll_layer->id());
+        layer_tree_impl->InnerViewportContainerLayer()->id(), clip_layer->id(),
+        inner_scroll->id(), scroll_layer->id());
     layer_tree_impl->BuildPropertyTreesForTesting();
     DrawFrame();
   }
 
   ASSERT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
   // Scrolling should scroll the child content and the browser controls. The
   // original outer viewport should get no scroll.
   {
     host_impl_->ScrollBegin(BeginState(gfx::Point(0, 0)).get(),
@@ skipping 2505 matching lines @@
     else
       EXPECT_FALSE(tile->HasRasterTask());
   }
   Region expected_invalidation(
       raster_source->GetRectForImage(checkerable_image.stable_id()));
   EXPECT_EQ(expected_invalidation, *(root->GetPendingInvalidation()));
 }
 
 }  // namespace
 }  // namespace cc