Rename classes related to top controls

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 61 matching lines @@
 }
 
 namespace cc {
 class Layer;
 }
 
 using blink::WebFloatPoint;
 using blink::WebRect;
 using blink::WebSelection;
 using blink::WebSize;
-using blink::WebTopControlsState;
+using blink::WebBrowserControlsState;
 
 namespace content {
 namespace {
 
 bool GetSwitchValueAsInt(const base::CommandLine& command_line,
                          const std::string& switch_string,
                          int min_value,
                          int max_value,
                          int* result) {
   std::string string_value = command_line.GetSwitchValueASCII(switch_string);
@@ skipping 90 matching lines @@
   }
 #elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
   // Use 512 for high DPI (dsf=2.0f) devices.
   if (initial_device_scale_factor >= 2.0f)
     default_tile_size = 512;
 #endif
 
   return gfx::Size(default_tile_size, default_tile_size);
 }
 
-// Check cc::TopControlsState, and blink::WebTopControlsState
+// Check cc::BrowserControlsState, and blink::WebBrowserControlsState
 // are kept in sync.
-static_assert(int(blink::WebTopControlsBoth) == int(cc::BOTH),
+static_assert(int(blink::WebBrowserControlsBoth) == int(cc::BOTH),
               "mismatching enums: BOTH");
-static_assert(int(blink::WebTopControlsHidden) == int(cc::HIDDEN),
+static_assert(int(blink::WebBrowserControlsHidden) == int(cc::HIDDEN),
               "mismatching enums: HIDDEN");
-static_assert(int(blink::WebTopControlsShown) == int(cc::SHOWN),
+static_assert(int(blink::WebBrowserControlsShown) == int(cc::SHOWN),
               "mismatching enums: SHOWN");
 
-static cc::TopControlsState ConvertTopControlsState(
-    WebTopControlsState state) {
-  return static_cast<cc::TopControlsState>(state);
+static cc::BrowserControlsState ConvertBrowserControlsState(
+    WebBrowserControlsState state) {
+  return static_cast<cc::BrowserControlsState>(state);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
     RenderWidgetCompositorDelegate* delegate,
     float device_scale_factor,
     CompositorDependencies* compositor_deps) {
   std::unique_ptr<RenderWidgetCompositor> compositor(
@@ skipping 113 matching lines @@
   settings.renderer_settings.use_gpu_memory_buffer_resources =
       compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
   settings.enable_color_correct_rendering =
       cmd.HasSwitch(cc::switches::kEnableColorCorrectRendering);
   settings.renderer_settings.buffer_to_texture_target_map =
       compositor_deps->GetBufferToTextureTargetMap();
   settings.image_decode_tasks_enabled =
       compositor_deps->AreImageDecodeTasksEnabled();
 
   // Build LayerTreeSettings from command line args.
-  LayerTreeSettingsFactory::SetTopControlsSettings(settings, cmd);
+  LayerTreeSettingsFactory::SetBrowserControlsSettings(settings, cmd);
 
   settings.use_layer_lists = cmd.HasSwitch(cc::switches::kEnableLayerLists);
 
   settings.renderer_settings.allow_antialiasing &=
       !cmd.HasSwitch(cc::switches::kDisableCompositedAntialiasing);
   // The means the renderer compositor has 2 possible modes:
   // - Threaded compositing with a scheduler.
   // - Single threaded compositing without a scheduler (for layout tests only).
   // Using the scheduler in layout tests introduces additional composite steps
   // that create flakiness.
@@ skipping 609 matching lines @@
 }
 
 void RenderWidgetCompositor::setShowScrollBottleneckRects(bool show) {
   cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
   debug_state.show_touch_event_handler_rects = show;
   debug_state.show_wheel_event_handler_rects = show;
   debug_state.show_non_fast_scrollable_rects = show;
   layer_tree_host_->SetDebugState(debug_state);
 }
 
-void RenderWidgetCompositor::updateTopControlsState(
-    WebTopControlsState constraints,
-    WebTopControlsState current,
+void RenderWidgetCompositor::updateBrowserControlsState(
+    WebBrowserControlsState constraints,
+    WebBrowserControlsState current,
     bool animate) {
-  layer_tree_host_->UpdateTopControlsState(ConvertTopControlsState(constraints),
-                                           ConvertTopControlsState(current),
-                                           animate);
+  layer_tree_host_->UpdateBrowserControlsState(
+      ConvertBrowserControlsState(constraints),
+      ConvertBrowserControlsState(current), animate);
 }
 
-void RenderWidgetCompositor::setTopControlsHeight(float height, bool shrink) {
-  layer_tree_host_->GetLayerTree()->SetTopControlsHeight(height, shrink);
+void RenderWidgetCompositor::setBrowserControlsHeight(float height,
+                                                      bool shrink) {
+  layer_tree_host_->GetLayerTree()->SetBrowserControlsHeight(height, shrink);
 }
 
-void RenderWidgetCompositor::setTopControlsShownRatio(float ratio) {
-  layer_tree_host_->GetLayerTree()->SetTopControlsShownRatio(ratio);
+void RenderWidgetCompositor::setBrowserControlsShownRatio(float ratio) {
+  layer_tree_host_->GetLayerTree()->SetBrowserControlsShownRatio(ratio);
 }
 
 void RenderWidgetCompositor::setBottomControlsHeight(float height) {
   layer_tree_host_->GetLayerTree()->SetBottomControlsHeight(height);
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
   delegate_->WillBeginCompositorFrame();
 }
 
@@ skipping 132 matching lines @@
     float device_scale) {
   layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
   layer_tree_host_->GetLayerTree()->SetDeviceColorSpace(color_space);
 }
 
 }  // namespace content