Refactor SetViewportLayerIds to use a struct instead of 6 values

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 61 matching lines @@
     scoped_refptr<SyncedBrowserControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       is_first_frame_after_commit_tracker_(-1),
       root_layer_for_testing_(nullptr),
       hud_layer_(nullptr),
       background_color_(0),
       has_transparent_background_(false),
       last_scrolled_scroll_node_index_(ScrollTree::kInvalidNodeId),
-      overscroll_elasticity_layer_id_(Layer::INVALID_ID),
-      page_scale_layer_id_(Layer::INVALID_ID),
-      inner_viewport_container_layer_id_(Layer::INVALID_ID),
-      outer_viewport_container_layer_id_(Layer::INVALID_ID),
-      inner_viewport_scroll_layer_id_(Layer::INVALID_ID),
-      outer_viewport_scroll_layer_id_(Layer::INVALID_ID),
       page_scale_factor_(page_scale_factor),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       device_scale_factor_(1.f),
       painted_device_scale_factor_(1.f),
       content_source_id_(0),
       elastic_overscroll_(elastic_overscroll),
       layers_(new OwnedLayerImplList),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
@@ skipping 54 matching lines @@
   if (!LayerListIsEmpty()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         this, [](LayerImpl* layer) { layer->RecreateTileResources(); });
   }
 }
 
 bool LayerTreeImpl::IsViewportLayerId(int id) const {
 #if DCHECK_IS_ON()
   // Ensure the LayerImpl viewport layer types correspond to the LayerTreeImpl's
   // viewport layers.
-  if (id == inner_viewport_container_layer_id_)
+  if (id == viewport_layer_ids_.inner_viewport_container)
     DCHECK(LayerById(id)->viewport_layer_type() == INNER_VIEWPORT_CONTAINER);
-  if (id == outer_viewport_container_layer_id_)
+  if (id == viewport_layer_ids_.outer_viewport_container)
     DCHECK(LayerById(id)->viewport_layer_type() == OUTER_VIEWPORT_CONTAINER);
-  if (id == inner_viewport_scroll_layer_id_)
+  if (id == viewport_layer_ids_.inner_viewport_scroll)
     DCHECK(LayerById(id)->viewport_layer_type() == INNER_VIEWPORT_SCROLL);
-  if (id == outer_viewport_scroll_layer_id_)
+  if (id == viewport_layer_ids_.outer_viewport_scroll)
     DCHECK(LayerById(id)->viewport_layer_type() == OUTER_VIEWPORT_SCROLL);
 #endif
   if (auto* layer = LayerById(id))
     return layer->viewport_layer_type() != NOT_VIEWPORT_LAYER;
   return false;
 }
 
 void LayerTreeImpl::DidUpdateScrollOffset(int layer_id) {
   DidUpdateScrollState(layer_id);
   DCHECK(lifecycle().AllowsPropertyTreeAccess());
@@ skipping 42 matching lines @@
     return;
 
   int scroll_layer_id, clip_layer_id;
   if (IsViewportLayerId(layer_id)) {
     if (!InnerViewportContainerLayer())
       return;
 
     // For scrollbar purposes, a change to any of the four viewport layers
     // should affect the scrollbars tied to the outermost layers, which express
     // the sum of the entire viewport.
-    scroll_layer_id = outer_viewport_scroll_layer_id_;
-    clip_layer_id = InnerViewportContainerLayer()->id();
+    scroll_layer_id = viewport_layer_ids_.outer_viewport_scroll;
+    clip_layer_id = viewport_layer_ids_.inner_viewport_container;
   } else {
     // If the clip layer id was passed in, then look up the scroll layer, or
     // vice versa.
     auto i = clip_scroll_map_.find(layer_id);
     if (i != clip_scroll_map_.end()) {
       scroll_layer_id = i->second;
       clip_layer_id = layer_id;
     } else {
       scroll_layer_id = layer_id;
       clip_layer_id = LayerById(scroll_layer_id)->scroll_clip_layer_id();
@@ skipping 93 matching lines @@
     return;
 
   for (auto* picture_layer : picture_layers_)
     picture_layer->InvalidateRegionForImages(images_to_invalidate);
 }
 
 bool LayerTreeImpl::IsRootLayer(const LayerImpl* layer) const {
   return layer_list_.empty() ? false : layer_list_[0] == layer;
 }
 
-LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
-  return LayerById(inner_viewport_scroll_layer_id_);
-}
-
-LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
-  return LayerById(outer_viewport_scroll_layer_id_);
-}
-
 gfx::ScrollOffset LayerTreeImpl::TotalScrollOffset() const {
   gfx::ScrollOffset offset;
 
   if (InnerViewportScrollLayer())
     offset += InnerViewportScrollLayer()->CurrentScrollOffset();
 
   if (OuterViewportScrollLayer())
     offset += OuterViewportScrollLayer()->CurrentScrollOffset();
 
   return offset;
@@ skipping 80 matching lines @@
   swap_promise_list_.clear();
 
   target_tree->set_browser_controls_shrink_blink_size(
       browser_controls_shrink_blink_size_);
   target_tree->set_top_controls_height(top_controls_height_);
   target_tree->set_bottom_controls_height(bottom_controls_height_);
   target_tree->PushBrowserControls(nullptr);
 
   // The page scale factor update can affect scrolling which requires that
   // these ids are set, so this must be before PushPageScaleFactorAndLimits.
-  target_tree->SetViewportLayersFromIds(
-      overscroll_elasticity_layer_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_);
+  target_tree->SetViewportLayersFromIds(viewport_layer_ids_);
 
   // Active tree already shares the page_scale_factor object with pending
   // tree so only the limits need to be provided.
   target_tree->PushPageScaleFactorAndLimits(nullptr, min_page_scale_factor(),
                                             max_page_scale_factor());
   target_tree->SetDeviceScaleFactor(device_scale_factor());
   target_tree->set_painted_device_scale_factor(painted_device_scale_factor());
   target_tree->SetRasterColorSpace(raster_color_space_);
   target_tree->elastic_overscroll()->PushPendingToActive();
 
@@ skipping 173 matching lines @@
 
 void LayerTreeImpl::SetFilterMutated(ElementId element_id,
                                      const FilterOperations& filters) {
   DCHECK_EQ(
       1u, property_trees()->element_id_to_effect_node_index.count(element_id));
   element_id_to_filter_animations_[element_id] = filters;
   if (property_trees()->effect_tree.OnFilterAnimated(element_id, filters))
     set_needs_update_draw_properties();
 }
 
-LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
-  return LayerById(inner_viewport_container_layer_id_);
-}
-
-LayerImpl* LayerTreeImpl::OuterViewportContainerLayer() const {
-  return LayerById(outer_viewport_container_layer_id_);
-}
-
 ScrollNode* LayerTreeImpl::CurrentlyScrollingNode() {
   DCHECK(IsActiveTree());
   return property_trees_.scroll_tree.CurrentlyScrollingNode();
 }
 
 const ScrollNode* LayerTreeImpl::CurrentlyScrollingNode() const {
   return property_trees_.scroll_tree.CurrentlyScrollingNode();
 }
 
 int LayerTreeImpl::LastScrolledScrollNodeIndex() const {
@@ skipping 256 matching lines @@
 
   return true;
 }
 
 void LayerTreeImpl::DidUpdatePageScale() {
   if (IsActiveTree())
     page_scale_factor()->SetCurrent(
         ClampPageScaleFactorToLimits(current_page_scale_factor()));
 
   set_needs_update_draw_properties();
-  DidUpdateScrollState(inner_viewport_scroll_layer_id_);
+  DidUpdateScrollState(viewport_layer_ids_.inner_viewport_scroll);
 
   if (IsActiveTree() && layer_tree_host_impl_->ViewportMainScrollLayer()) {
     if (ScrollbarAnimationController* controller =
             layer_tree_host_impl_->ScrollbarAnimationControllerForElementId(
                 OuterViewportScrollLayer()->element_id()))
       controller->DidScrollUpdate();
   }
 }
 
 void LayerTreeImpl::SetDeviceScaleFactor(float device_scale_factor) {
@@ skipping 47 matching lines @@
   page_scale_factor()->AbortCommit();
   top_controls_shown_ratio()->AbortCommit();
   elastic_overscroll()->AbortCommit();
 
   if (layer_list_.empty())
     return;
 
   property_trees()->scroll_tree.ApplySentScrollDeltasFromAbortedCommit();
 }
 
-void LayerTreeImpl::SetViewportLayersFromIds(
-    int overscroll_elasticity_layer_id,
-    int page_scale_layer_id,
-    int inner_viewport_container_layer_id,
-    int outer_viewport_container_layer_id,
-    int inner_viewport_scroll_layer_id,
-    int outer_viewport_scroll_layer_id) {
-  overscroll_elasticity_layer_id_ = overscroll_elasticity_layer_id;
-  page_scale_layer_id_ = page_scale_layer_id;
-  inner_viewport_container_layer_id_ = inner_viewport_container_layer_id;
-  outer_viewport_container_layer_id_ = outer_viewport_container_layer_id;
-  inner_viewport_scroll_layer_id_ = inner_viewport_scroll_layer_id;
-  outer_viewport_scroll_layer_id_ = outer_viewport_scroll_layer_id;
+void LayerTreeImpl::SetViewportLayersFromIds(const ViewportLayerIds& ids) {
+  viewport_layer_ids_ = ids;
 
-  if (auto* inner_container = LayerById(inner_viewport_container_layer_id_))
+  // Set the viewport layer types.
+  if (auto* inner_container = InnerViewportContainerLayer())
     inner_container->SetViewportLayerType(INNER_VIEWPORT_CONTAINER);
-  if (auto* inner_scroll = LayerById(inner_viewport_scroll_layer_id_))
+  if (auto* inner_scroll = InnerViewportScrollLayer())
     inner_scroll->SetViewportLayerType(INNER_VIEWPORT_SCROLL);
-  if (auto* outer_container = LayerById(outer_viewport_container_layer_id_))
+  if (auto* outer_container = OuterViewportContainerLayer())
     outer_container->SetViewportLayerType(OUTER_VIEWPORT_CONTAINER);
-  if (auto* outer_scroll = LayerById(outer_viewport_scroll_layer_id_))
+  if (auto* outer_scroll = OuterViewportScrollLayer())
     outer_scroll->SetViewportLayerType(OUTER_VIEWPORT_SCROLL);
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
-  SetViewportLayersFromIds(Layer::INVALID_ID, Layer::INVALID_ID,
-                           Layer::INVALID_ID, Layer::INVALID_ID,
-                           Layer::INVALID_ID, Layer::INVALID_ID);
+  SetViewportLayersFromIds(ViewportLayerIds());
 }
 
 // For unit tests, we use the layer's id as its element id.
 static void SetElementIdForTesting(LayerImpl* layer) {
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeImpl::SetElementIdsForTesting() {
   LayerListIterator<LayerImpl> it(root_layer_for_testing_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
@@ skipping 1097 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc