Refactor SetViewportLayerIds to use a struct instead of 6 values

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 363 matching lines @@
 
     outer_scroll->test_properties()->AddChild(std::move(contents));
     outer_clip->test_properties()->AddChild(std::move(outer_scroll));
     inner_scroll->test_properties()->AddChild(std::move(outer_clip));
     page_scale->test_properties()->AddChild(std::move(inner_scroll));
     inner_clip->test_properties()->AddChild(std::move(page_scale));
     root->test_properties()->AddChild(std::move(inner_clip));
 
     layer_tree_impl->SetRootLayerForTesting(std::move(root));
     layer_tree_impl->BuildPropertyTreesForTesting();
-    layer_tree_impl->SetViewportLayersFromIds(
-        Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportClipLayerId,
-        kOuterViewportClipLayerId, kInnerViewportScrollLayerId,
-        kOuterViewportScrollLayerId);
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = kPageScaleLayerId;
+    viewport_ids.inner_viewport_container = kInnerViewportClipLayerId;
+    viewport_ids.outer_viewport_container = kOuterViewportClipLayerId;
+    viewport_ids.inner_viewport_scroll = kInnerViewportScrollLayerId;
+    viewport_ids.outer_viewport_scroll = kOuterViewportScrollLayerId;
+    layer_tree_impl->SetViewportLayersFromIds(viewport_ids);
 
     layer_tree_impl->DidBecomeActive();
     return layer_tree_impl->InnerViewportScrollLayer();
   }
 
   LayerImpl* SetupScrollAndContentsLayers(const gfx::Size& content_size) {
     LayerImpl* scroll_layer =
         CreateScrollAndContentsLayers(host_impl_->active_tree(), content_size);
     host_impl_->active_tree()->DidBecomeActive();
     return scroll_layer;
@@ skipping 3906 matching lines @@
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
 
     outer_clip->test_properties()->AddChild(std::move(outer_scroll));
     root->test_properties()->AddChild(std::move(outer_clip));
     page_scale->test_properties()->AddChild(std::move(root));
     root_clip->test_properties()->AddChild(std::move(page_scale));
 
     tree_impl->SetRootLayerForTesting(std::move(root_clip));
-    tree_impl->SetViewportLayersFromIds(
-        Layer::INVALID_ID, page_scale_layer_id,
-        inner_viewport_container_layer_id, outer_viewport_container_layer_id,
-        inner_viewport_scroll_layer_id, outer_viewport_scroll_layer_id);
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = page_scale_layer_id;
+    viewport_ids.inner_viewport_container = inner_viewport_container_layer_id;
+    viewport_ids.outer_viewport_container = outer_viewport_container_layer_id;
+    viewport_ids.inner_viewport_scroll = inner_viewport_scroll_layer_id;
+    viewport_ids.outer_viewport_scroll = outer_viewport_scroll_layer_id;
+    tree_impl->SetViewportLayersFromIds(viewport_ids);
     tree_impl->BuildPropertyTreesForTesting();
 
     host_impl_->SetViewportSize(inner_viewport_size);
     LayerImpl* root_clip_ptr = tree_impl->root_layer_for_testing();
     EXPECT_EQ(inner_viewport_size, root_clip_ptr->bounds());
   }
 
  protected:
   gfx::Size layer_size_;
   gfx::Size clip_size_;
@@ skipping 1400 matching lines @@
   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, kPageScaleLayerId, kViewportClipLayerId,
-      Layer::INVALID_ID, kViewportScrollLayerId, Layer::INVALID_ID);
+  LayerTreeImpl::ViewportLayerIds viewport_ids;
+  viewport_ids.page_scale = kPageScaleLayerId;
+  viewport_ids.inner_viewport_container = kViewportClipLayerId;
+  viewport_ids.inner_viewport_scroll = kViewportScrollLayerId;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids);
   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 121 matching lines @@
       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, kPageScaleLayerId, kViewportClipLayerId,
-      Layer::INVALID_ID, kViewportScrollLayerId, Layer::INVALID_ID);
+  LayerTreeImpl::ViewportLayerIds viewport_ids;
+  viewport_ids.page_scale = kPageScaleLayerId;
+  viewport_ids.inner_viewport_container = kViewportClipLayerId;
+  viewport_ids.inner_viewport_scroll = kViewportScrollLayerId;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids);
   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(),
@@ skipping 32 matching lines @@
   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, kPageScaleLayerId, kInnerViewportClipLayerId,
-      kOuterViewportClipLayerId, kInnerViewportScrollLayerId,
-      kOuterViewportScrollLayerId);
+  LayerTreeImpl::ViewportLayerIds viewport_ids;
+  viewport_ids.page_scale = kPageScaleLayerId;
+  viewport_ids.inner_viewport_container = kInnerViewportClipLayerId;
+  viewport_ids.outer_viewport_container = kOuterViewportClipLayerId;
+  viewport_ids.inner_viewport_scroll = kInnerViewportScrollLayerId;
+  viewport_ids.outer_viewport_scroll = kOuterViewportScrollLayerId;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids);
   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;
@@ skipping 16 matching lines @@
       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, kPageScaleLayerId2, kInnerViewportClipLayerId2,
-      kOuterViewportClipLayerId2, kInnerViewportScrollLayerId2,
-      kOuterViewportScrollLayerId2);
+  LayerTreeImpl::ViewportLayerIds viewport_ids2;
+  viewport_ids2.page_scale = kPageScaleLayerId2;
+  viewport_ids2.inner_viewport_container = kInnerViewportClipLayerId2;
+  viewport_ids2.outer_viewport_container = kOuterViewportClipLayerId2;
+  viewport_ids2.inner_viewport_scroll = kInnerViewportScrollLayerId2;
+  viewport_ids2.outer_viewport_scroll = kOuterViewportScrollLayerId2;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids2);
   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 563 matching lines @@
       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, kInnerViewportClipLayerId,
-      Layer::INVALID_ID, kInnerViewportScrollLayerId, Layer::INVALID_ID);
+  LayerTreeImpl::ViewportLayerIds viewport_ids;
+  viewport_ids.inner_viewport_container = kInnerViewportClipLayerId;
+  viewport_ids.inner_viewport_scroll = kInnerViewportScrollLayerId;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids);
 
   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 382 matching lines @@
     scroll2->SetDrawsContent(true);
 
     scroll_layer = scroll.get();
     child_scroll_layer = scroll2.get();
 
     clip2->test_properties()->AddChild(std::move(scroll2));
     scroll->test_properties()->AddChild(std::move(clip2));
 
     clip->test_properties()->AddChild(std::move(scroll));
     content_layer->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_layer->id(),
-        scroll_layer->id());
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = layer_tree_impl->PageScaleLayer()->id();
+    viewport_ids.inner_viewport_scroll = inner_scroll_layer->id();
+    viewport_ids.outer_viewport_scroll = scroll_layer->id();
+    layer_tree_impl->SetViewportLayersFromIds(viewport_ids);
     layer_tree_impl->BuildPropertyTreesForTesting();
   }
 
   // Scroll should target the nested scrolling layer in the content and then
   // chain to the parent scrolling layer which is now set as the outer
   // viewport. The original outer viewport layer shouldn't get any scroll here.
   {
     host_impl_->ScrollBegin(BeginState(gfx::Point(0, 0)).get(),
                             InputHandler::TOUCHSCREEN);
     host_impl_->ScrollBy(
@@ skipping 114 matching lines @@
     scroll2->SetElementId(LayerIdToElementIdForTesting(scroll2->id()));
     scroll2->SetDrawsContent(true);
 
     sibling_scroll_layer = scroll2.get();
 
     clip2->test_properties()->AddChild(std::move(scroll2));
     content_layer->test_properties()->AddChild(std::move(clip2));
 
     LayerImpl* inner_container =
         host_impl_->active_tree()->InnerViewportContainerLayer();
-    layer_tree_impl->SetViewportLayersFromIds(
-        Layer::INVALID_ID, layer_tree_impl->PageScaleLayer()->id(),
-        inner_container->id(), Layer::INVALID_ID, inner_scroll_layer->id(),
-        outer_scroll_layer->id());
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = layer_tree_impl->PageScaleLayer()->id();
+    viewport_ids.inner_viewport_container = inner_container->id();
+    viewport_ids.inner_viewport_scroll = inner_scroll_layer->id();
+    viewport_ids.outer_viewport_scroll = outer_scroll_layer->id();
+    layer_tree_impl->SetViewportLayersFromIds(viewport_ids);
     layer_tree_impl->BuildPropertyTreesForTesting();
 
     ASSERT_EQ(outer_scroll_layer, layer_tree_impl->OuterViewportScrollLayer());
   }
 
   // Scrolls should target the non-descendant scroller. Chaining should not
   // propagate to the outer viewport scroll layer.
   {
     // This should fully scroll the layer.
     host_impl_->ScrollBegin(BeginState(gfx::Point(0, 0)).get(),
@@ skipping 1752 matching lines @@
   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, kPageScaleLayerId, kInnerViewportClipLayerId,
-      Layer::INVALID_ID, kInnerViewportScrollLayerId, Layer::INVALID_ID);
+  LayerTreeImpl::ViewportLayerIds viewport_ids;
+  viewport_ids.page_scale = kPageScaleLayerId;
+  viewport_ids.inner_viewport_container = kInnerViewportClipLayerId;
+  viewport_ids.inner_viewport_scroll = kInnerViewportScrollLayerId;
+  host_impl_->active_tree()->SetViewportLayersFromIds(viewport_ids);
   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 1007 matching lines @@
     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_tree_impl->InnerViewportContainerLayer()->id(), clip_layer->id(),
-        inner_scroll->id(), scroll_layer->id());
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = layer_tree_impl->PageScaleLayer()->id();
+    viewport_ids.inner_viewport_container =
+        layer_tree_impl->InnerViewportContainerLayer()->id();
+    viewport_ids.outer_viewport_container = clip_layer->id();
+    viewport_ids.inner_viewport_scroll = inner_scroll->id();
+    viewport_ids.outer_viewport_scroll = scroll_layer->id();
+    layer_tree_impl->SetViewportLayersFromIds(viewport_ids);
     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 68 matching lines @@
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->test_properties()->AddChild(std::move(contents));
     outer_clip->test_properties()->AddChild(std::move(outer_scroll));
     inner_scroll->test_properties()->AddChild(std::move(outer_clip));
     page_scale->test_properties()->AddChild(std::move(inner_scroll));
     inner_clip->test_properties()->AddChild(std::move(page_scale));
 
     inner_clip->test_properties()->force_render_surface = true;
     layer_tree_impl->SetRootLayerForTesting(std::move(inner_clip));
-    layer_tree_impl->SetViewportLayersFromIds(
-        Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportClipLayerId,
-        kOuterViewportClipLayerId, kInnerViewportScrollLayerId,
-        kOuterViewportScrollLayerId);
+    LayerTreeImpl::ViewportLayerIds viewport_ids;
+    viewport_ids.page_scale = kPageScaleLayerId;
+    viewport_ids.inner_viewport_container = kInnerViewportClipLayerId;
+    viewport_ids.outer_viewport_container = kOuterViewportClipLayerId;
+    viewport_ids.inner_viewport_scroll = kInnerViewportScrollLayerId;
+    viewport_ids.outer_viewport_scroll = kOuterViewportScrollLayerId;
+    layer_tree_impl->SetViewportLayersFromIds(viewport_ids);
 
     host_impl_->active_tree()->BuildPropertyTreesForTesting();
     host_impl_->active_tree()->DidBecomeActive();
   }
 };
 
 TEST_F(LayerTreeHostImplVirtualViewportTest, ScrollBothInnerAndOuterLayer) {
   gfx::Size content_size = gfx::Size(100, 160);
   gfx::Size outer_viewport = gfx::Size(50, 80);
   gfx::Size inner_viewport = gfx::Size(25, 40);
@@ skipping 2415 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