Rename classes related to top controls

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 38 matching lines @@
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
-    scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
+    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_layer_id_(Layer::INVALID_ID),
       overscroll_elasticity_layer_id_(Layer::INVALID_ID),
       page_scale_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),
       elastic_overscroll_(elastic_overscroll),
       layers_(new OwnedLayerImplList),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true),
       next_activation_forces_redraw_(false),
       has_ever_been_drawn_(false),
       have_scroll_event_handlers_(false),
       event_listener_properties_(),
-      top_controls_shrink_blink_size_(false),
+      browser_controls_shrink_blink_size_(false),
       top_controls_height_(0),
       bottom_controls_height_(0),
       top_controls_shown_ratio_(top_controls_shown_ratio) {
   property_trees()->is_main_thread = false;
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   BreakSwapPromises(IsActiveTree() ? SwapPromise::SWAP_FAILS
                                    : SwapPromise::ACTIVATION_FAILS);
 
@@ skipping 314 matching lines @@
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   LayerImpl* layer = target_tree->CurrentlyScrollingLayer();
   target_tree->SetPropertyTrees(&property_trees_);
   target_tree->SetCurrentlyScrollingLayer(layer);
   target_tree->UpdatePropertyTreeScrollOffset(&property_trees_);
 
   // This needs to be called early so that we don't clamp with incorrect max
   // offsets when UpdateViewportContainerSizes is called from e.g.
-  // PushTopControls
+  // PushBrowserControls
   target_tree->UpdatePropertyTreesForBoundsDelta();
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
     next_activation_forces_redraw_ = false;
   }
 
   target_tree->PassSwapPromises(std::move(swap_promise_list_));
   swap_promise_list_.clear();
 
-  target_tree->set_top_controls_shrink_blink_size(
-      top_controls_shrink_blink_size_);
+  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->PushTopControls(nullptr);
+  target_tree->PushBrowserControls(nullptr);
 
   // 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->SetDeviceColorSpace(device_color_space_);
   target_tree->elastic_overscroll()->PushPendingToActive();
 
@@ skipping 314 matching lines @@
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
           device_scale_factor(), layer_tree_host_impl_->DrawTransform());
     } else {
       DCHECK(layer_list_.empty() || *page_scale_factor == 1);
     }
   }
 }
 
-void LayerTreeImpl::set_top_controls_shrink_blink_size(bool shrink) {
-  if (top_controls_shrink_blink_size_ == shrink)
+void LayerTreeImpl::set_browser_controls_shrink_blink_size(bool shrink) {
+  if (browser_controls_shrink_blink_size_ == shrink)
     return;
 
-  top_controls_shrink_blink_size_ = shrink;
+  browser_controls_shrink_blink_size_ = shrink;
   if (IsActiveTree())
     layer_tree_host_impl_->UpdateViewportContainerSizes();
 }
 
 void LayerTreeImpl::set_top_controls_height(float top_controls_height) {
   if (top_controls_height_ == top_controls_height)
     return;
 
   top_controls_height_ = top_controls_height;
   if (IsActiveTree())
     layer_tree_host_impl_->UpdateViewportContainerSizes();
 }
 
 void LayerTreeImpl::set_bottom_controls_height(float bottom_controls_height) {
   if (bottom_controls_height_ == bottom_controls_height)
     return;
 
   bottom_controls_height_ = bottom_controls_height;
   if (IsActiveTree())
     layer_tree_host_impl_->UpdateViewportContainerSizes();
 }
 
-bool LayerTreeImpl::ClampTopControlsShownRatio() {
+bool LayerTreeImpl::ClampBrowserControlsShownRatio() {
   float ratio = top_controls_shown_ratio_->Current(true);
   ratio = std::max(ratio, 0.f);
   ratio = std::min(ratio, 1.f);
   return top_controls_shown_ratio_->SetCurrent(ratio);
 }
 
-bool LayerTreeImpl::SetCurrentTopControlsShownRatio(float ratio) {
+bool LayerTreeImpl::SetCurrentBrowserControlsShownRatio(float ratio) {
   bool changed = top_controls_shown_ratio_->SetCurrent(ratio);
-  changed |= ClampTopControlsShownRatio();
+  changed |= ClampBrowserControlsShownRatio();
   return changed;
 }
 
-void LayerTreeImpl::PushTopControlsFromMainThread(
+void LayerTreeImpl::PushBrowserControlsFromMainThread(
     float top_controls_shown_ratio) {
-  PushTopControls(&top_controls_shown_ratio);
+  PushBrowserControls(&top_controls_shown_ratio);
 }
 
-void LayerTreeImpl::PushTopControls(const float* top_controls_shown_ratio) {
+void LayerTreeImpl::PushBrowserControls(const float* top_controls_shown_ratio) {
   DCHECK(top_controls_shown_ratio || IsActiveTree());
 
   if (top_controls_shown_ratio) {
     DCHECK(!IsActiveTree() || !layer_tree_host_impl_->pending_tree());
     top_controls_shown_ratio_->PushFromMainThread(*top_controls_shown_ratio);
   }
   if (IsActiveTree()) {
     bool changed_active = top_controls_shown_ratio_->PushPendingToActive();
-    changed_active |= ClampTopControlsShownRatio();
+    changed_active |= ClampBrowserControlsShownRatio();
     if (changed_active)
-      layer_tree_host_impl_->DidChangeTopControlsPosition();
+      layer_tree_host_impl_->DidChangeBrowserControlsPosition();
   }
 }
 
 bool LayerTreeImpl::SetPageScaleFactorLimits(float min_page_scale_factor,
                                              float max_page_scale_factor) {
   if (min_page_scale_factor == min_page_scale_factor_ &&
       max_page_scale_factor == max_page_scale_factor_)
     return false;
 
   min_page_scale_factor_ = min_page_scale_factor;
@@ skipping 1237 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