Rename classes related to top controls

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>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
+#include "cc/input/browser_controls_offset_manager.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/input/scrollbar_animation_controller_thinning.h"
-#include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/layers/viewport.h"
@@ skipping 3860 matching lines @@
   pending_outer_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(pending_outer_layer->id(),
                                                      pending_scroll);
 
   host_impl_->ActivateSyncTree();
   // Scrolloffsets on the active tree will be clamped after activation.
   EXPECT_EQ(active_outer_layer->CurrentScrollOffset(), gfx::ScrollOffset(0, 0));
 }
 
-class LayerTreeHostImplTopControlsTest : public LayerTreeHostImplTest {
+class LayerTreeHostImplBrowserControlsTest : public LayerTreeHostImplTest {
  public:
-  LayerTreeHostImplTopControlsTest()
+  LayerTreeHostImplBrowserControlsTest()
       // Make the clip size the same as the layer (content) size so the layer is
       // non-scrollable.
       : layer_size_(10, 10),
         clip_size_(layer_size_),
         top_controls_height_(50) {
     viewport_size_ = gfx::Size(clip_size_.width(),
                                clip_size_.height() + top_controls_height_);
   }
 
   bool CreateHostImpl(
       const LayerTreeSettings& settings,
       std::unique_ptr<CompositorFrameSink> compositor_frame_sink) override {
     bool init = LayerTreeHostImplTest::CreateHostImpl(
         settings, std::move(compositor_frame_sink));
     if (init) {
       host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
-      host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
+      host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(1.f);
       host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     }
     return init;
   }
 
-  void SetupTopControlsAndScrollLayerWithVirtualViewport(
+  void SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       const gfx::Size& inner_viewport_size,
       const gfx::Size& outer_viewport_size,
       const gfx::Size& scroll_layer_size) {
     settings_ = DefaultSettings();
     CreateHostImpl(settings_, CreateCompositorFrameSink());
-    SetupTopControlsAndScrollLayerWithVirtualViewport(
+    SetupBrowserControlsAndScrollLayerWithVirtualViewport(
         host_impl_->active_tree(), inner_viewport_size, outer_viewport_size,
         scroll_layer_size);
   }
 
-  void SetupTopControlsAndScrollLayerWithVirtualViewport(
+  void SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       LayerTreeImpl* tree_impl,
       const gfx::Size& inner_viewport_size,
       const gfx::Size& outer_viewport_size,
       const gfx::Size& scroll_layer_size) {
-    tree_impl->set_top_controls_shrink_blink_size(true);
+    tree_impl->set_browser_controls_shrink_blink_size(true);
     tree_impl->set_top_controls_height(top_controls_height_);
-    tree_impl->SetCurrentTopControlsShownRatio(1.f);
+    tree_impl->SetCurrentBrowserControlsShownRatio(1.f);
     tree_impl->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
-    host_impl_->DidChangeTopControlsPosition();
+    host_impl_->DidChangeBrowserControlsPosition();
 
     std::unique_ptr<LayerImpl> root = LayerImpl::Create(tree_impl, 1);
     std::unique_ptr<LayerImpl> root_clip = LayerImpl::Create(tree_impl, 2);
     std::unique_ptr<LayerImpl> page_scale = LayerImpl::Create(tree_impl, 3);
 
     std::unique_ptr<LayerImpl> outer_scroll = LayerImpl::Create(tree_impl, 4);
     std::unique_ptr<LayerImpl> outer_clip = LayerImpl::Create(tree_impl, 5);
 
     root_clip->SetBounds(inner_viewport_size);
     root->SetScrollClipLayer(root_clip->id());
@@ skipping 30 matching lines @@
     EXPECT_EQ(inner_viewport_size, root_clip_ptr->bounds());
   }
 
  protected:
   gfx::Size layer_size_;
   gfx::Size clip_size_;
   gfx::Size viewport_size_;
   float top_controls_height_;
 
   LayerTreeSettings settings_;
-};  // class LayerTreeHostImplTopControlsTest
+};  // class LayerTreeHostImplBrowserControlsTest
 
 // Tests that, on a page with content the same size as the viewport, hiding
-// the top controls also increases the ScrollableSize (i.e. the content size).
-// Since the viewport got larger, the effective scrollable "content" also did.
-// This ensures, for one thing, that the overscroll glow is shown in the right
-// place.
-TEST_F(LayerTreeHostImplTopControlsTest,
-    HidingTopControlsExpandsScrollableSize) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// the browser controls also increases the ScrollableSize (i.e. the content
+// size). Since the viewport got larger, the effective scrollable "content" also
+// did. This ensures, for one thing, that the overscroll glow is shown in the
+// right place.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       HidingBrowserControlsExpandsScrollableSize) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(50, 50), gfx::Size(50, 50), gfx::Size(50, 50));
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
 
   // Create a content layer beneath the outer viewport scroll layer.
   int id = host_impl_->OuterViewportScrollLayer()->id();
   host_impl_->OuterViewportScrollLayer()->test_properties()->AddChild(
       LayerImpl::Create(host_impl_->active_tree(), id + 2));
   LayerImpl* content =
       active_tree->OuterViewportScrollLayer()->test_properties()->children[0];
   content->SetBounds(gfx::Size(50, 50));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   DrawFrame();
 
   LayerImpl* inner_container = active_tree->InnerViewportContainerLayer();
   LayerImpl* outer_container = active_tree->OuterViewportContainerLayer();
 
-  // The top controls should start off showing so the viewport should be shrunk.
+  // The browser controls should start off showing so the viewport should be
+  // shrunk.
   ASSERT_EQ(gfx::Size(50, 50), inner_container->bounds());
   ASSERT_EQ(gfx::Size(50, 50), outer_container->bounds());
 
   EXPECT_EQ(gfx::SizeF(50, 50), active_tree->ScrollableSize());
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 
-  host_impl_->top_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBegin();
 
-  // Hide the top controls by a bit, the scrollable size should increase but the
-  // actual content bounds shouldn't.
+  // Hide the browser controls by a bit, the scrollable size should increase but
+  // the actual content bounds shouldn't.
   {
-    host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
+    host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
     ASSERT_EQ(gfx::Size(50, 75), inner_container->bounds());
     ASSERT_EQ(gfx::Size(50, 75), outer_container->bounds());
     EXPECT_EQ(gfx::SizeF(50, 75), active_tree->ScrollableSize());
     EXPECT_EQ(gfx::SizeF(50, 50), content->BoundsForScrolling());
   }
 
-  // Fully hide the top controls.
+  // Fully hide the browser controls.
   {
-    host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
+    host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
     ASSERT_EQ(gfx::Size(50, 100), inner_container->bounds());
     ASSERT_EQ(gfx::Size(50, 100), outer_container->bounds());
     EXPECT_EQ(gfx::SizeF(50, 100), active_tree->ScrollableSize());
     EXPECT_EQ(gfx::SizeF(50, 50), content->BoundsForScrolling());
   }
 
   // Scrolling additionally shouldn't have any effect.
   {
-    host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
+    host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 25.f));
     ASSERT_EQ(gfx::Size(50, 100), inner_container->bounds());
     ASSERT_EQ(gfx::Size(50, 100), outer_container->bounds());
     EXPECT_EQ(gfx::SizeF(50, 100), active_tree->ScrollableSize());
     EXPECT_EQ(gfx::SizeF(50, 50), content->BoundsForScrolling());
   }
 
-  host_impl_->top_controls_manager()->ScrollEnd();
+  host_impl_->browser_controls_manager()->ScrollEnd();
   host_impl_->ScrollEnd(EndState().get());
 }
 
-TEST_F(LayerTreeHostImplTopControlsTest, ScrollTopControlsByFractionalAmount) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       ScrollBrowserControlsByFractionalAmount) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(10, 10), gfx::Size(10, 10), gfx::Size(10, 10));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 
   // Make the test scroll delta a fractional amount, to verify that the
   // fixed container size delta is (1) non-zero, and (2) fractional, and
-  // (3) matches the movement of the top controls.
+  // (3) matches the movement of the browser controls.
   gfx::Vector2dF top_controls_scroll_delta(0.f, 5.25f);
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
-  host_impl_->top_controls_manager()->ScrollEnd();
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(top_controls_scroll_delta);
+  host_impl_->browser_controls_manager()->ScrollEnd();
 
   LayerImpl* inner_viewport_scroll_layer =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   DCHECK(inner_viewport_scroll_layer);
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_FLOAT_EQ(top_controls_scroll_delta.y(),
                   inner_viewport_scroll_layer->FixedContainerSizeDelta().y());
 }
 
 // In this test, the outer viewport is initially unscrollable. We test that a
-// scroll initiated on the inner viewport, causing the top controls to show and
-// thus making the outer viewport scrollable, still scrolls the outer viewport.
-TEST_F(LayerTreeHostImplTopControlsTest,
-    TopControlsOuterViewportBecomesScrollable) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// scroll initiated on the inner viewport, causing the browser controls to show
+// and thus making the outer viewport scrollable, still scrolls the outer
+// viewport.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       BrowserControlsOuterViewportBecomesScrollable) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(10, 50), gfx::Size(10, 50), gfx::Size(10, 100));
   DrawFrame();
 
   LayerImpl* inner_scroll =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   inner_scroll->SetDrawsContent(true);
   LayerImpl* inner_container =
       host_impl_->active_tree()->InnerViewportContainerLayer();
   LayerImpl* outer_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   outer_scroll->SetDrawsContent(true);
   LayerImpl* outer_container =
       host_impl_->active_tree()->OuterViewportContainerLayer();
 
   // Need SetDrawsContent so ScrollBegin's hit test finds an actual layer.
   outer_scroll->SetDrawsContent(true);
   host_impl_->active_tree()->PushPageScaleFromMainThread(2.f, 1.f, 2.f);
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, 50.f)).get());
 
-  // The entire scroll delta should have been used to hide the top controls.
+  // The entire scroll delta should have been used to hide the browser controls.
   // The viewport layers should be resized back to their full sizes.
-  EXPECT_EQ(0.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  EXPECT_EQ(0.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(100.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(100.f, outer_container->BoundsForScrolling().height());
 
   // The inner viewport should be scrollable by 50px * page_scale.
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, 100.f)).get());
   EXPECT_EQ(50.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(gfx::ScrollOffset(), outer_scroll->MaxScrollOffset());
 
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), outer_scroll);
 
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, -50.f)).get());
 
-  // The entire scroll delta should have been used to show the top controls.
+  // The entire scroll delta should have been used to show the browser controls.
   // The outer viewport should be resized to accomodate and scrolled to the
   // bottom of the document to keep the viewport in place.
-  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
   EXPECT_EQ(50.f, outer_container->BoundsForScrolling().height());
   EXPECT_EQ(50.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(25.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
 
   // Now when we continue scrolling, make sure the outer viewport gets scrolled
   // since it wasn't scrollable when the scroll began.
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, -20.f)).get());
   EXPECT_EQ(25.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(15.f, inner_scroll->CurrentScrollOffset().y());
 
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, -30.f)).get());
   EXPECT_EQ(25.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
 
   host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2dF(0.f, -50.f)).get());
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
 }
 
 // Test that the fixed position container delta is appropriately adjusted
-// by the top controls showing/hiding and page scale doesn't affect it.
-TEST_F(LayerTreeHostImplTopControlsTest, FixedContainerDelta) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// by the browser controls showing/hiding and page scale doesn't affect it.
+TEST_F(LayerTreeHostImplBrowserControlsTest, FixedContainerDelta) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(100, 100), gfx::Size(100, 100));
   DrawFrame();
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 2.f);
 
   float page_scale = 1.5f;
   LayerImpl* outer_viewport_scroll_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer();
 
   // Zoom in, since the fixed container is the outer viewport, the delta should
   // not be scaled.
   host_impl_->active_tree()->PushPageScaleFromMainThread(page_scale, 1.f, 2.f);
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 
-  // Scroll down, the top controls hiding should expand the viewport size so
+  // Scroll down, the browser controls hiding should expand the viewport size so
   // the delta should be equal to the scroll distance.
   gfx::Vector2dF top_controls_scroll_delta(0.f, 20.f);
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(top_controls_scroll_delta);
   EXPECT_FLOAT_EQ(top_controls_height_ - top_controls_scroll_delta.y(),
-                  host_impl_->top_controls_manager()->ContentTopOffset());
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(top_controls_scroll_delta.y(),
                   outer_viewport_scroll_layer->FixedContainerSizeDelta().y());
   host_impl_->ScrollEnd(EndState().get());
 
   // Scroll past the maximum extent. The delta shouldn't be greater than the
-  // top controls height.
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
-  host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
-  host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  // browser controls height.
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(top_controls_scroll_delta);
+  host_impl_->browser_controls_manager()->ScrollBy(top_controls_scroll_delta);
+  host_impl_->browser_controls_manager()->ScrollBy(top_controls_scroll_delta);
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, top_controls_height_),
                    outer_viewport_scroll_layer->FixedContainerSizeDelta());
   host_impl_->ScrollEnd(EndState().get());
 
-  // Scroll in the direction to make the top controls show.
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(-top_controls_scroll_delta);
+  // Scroll in the direction to make the browser controls show.
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(-top_controls_scroll_delta);
   EXPECT_EQ(top_controls_scroll_delta.y(),
-            host_impl_->top_controls_manager()->ContentTopOffset());
+            host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_VECTOR_EQ(
       gfx::Vector2dF(0, top_controls_height_ - top_controls_scroll_delta.y()),
       outer_viewport_scroll_layer->FixedContainerSizeDelta());
-  host_impl_->top_controls_manager()->ScrollEnd();
+  host_impl_->browser_controls_manager()->ScrollEnd();
 }
 
-// Push a top controls ratio from the main thread that we didn't send as a delta
-// and make sure that the ratio is clamped to the [0, 1] range.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsPushUnsentRatio) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// Push a browser controls ratio from the main thread that we didn't send as a
+// delta and make sure that the ratio is clamped to the [0, 1] range.
+TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsPushUnsentRatio) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(10, 50), gfx::Size(10, 50), gfx::Size(10, 100));
   DrawFrame();
 
   // Need SetDrawsContent so ScrollBegin's hit test finds an actual layer.
   LayerImpl* inner_scroll =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   inner_scroll->SetDrawsContent(true);
   LayerImpl* outer_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   outer_scroll->SetDrawsContent(true);
 
-  host_impl_->active_tree()->PushTopControlsFromMainThread(1);
-  ASSERT_EQ(1.0f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  host_impl_->active_tree()->PushBrowserControlsFromMainThread(1);
+  ASSERT_EQ(1.0f,
+            host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.5f);
-  ASSERT_EQ(0.5f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(0.5f);
+  ASSERT_EQ(0.5f,
+            host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
-  host_impl_->active_tree()->PushTopControlsFromMainThread(0);
+  host_impl_->active_tree()->PushBrowserControlsFromMainThread(0);
 
-  ASSERT_EQ(0, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  ASSERT_EQ(0, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 }
 
-// Test that if only the top controls are scrolled, we shouldn't request a
+// Test that if only the browser controls are scrolled, we shouldn't request a
 // commit.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsDontTriggerCommit) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsDontTriggerCommit) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 50), gfx::Size(100, 100), gfx::Size(100, 100));
   DrawFrame();
 
-  // Show top controls
-  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  // Show browser controls
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
-  // Scroll 25px to hide top controls
+  // Scroll 25px to hide browser controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   EXPECT_FALSE(did_request_commit_);
 }
 
 // Test that if a scrollable sublayer doesn't consume the scroll,
-// top controls should hide when scrolling down.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsScrollableSublayer) {
+// browser controls should hide when scrolling down.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       BrowserControlsScrollableSublayer) {
   gfx::Size sub_content_size(100, 400);
   gfx::Size sub_content_layer_size(100, 300);
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 50), gfx::Size(100, 100), gfx::Size(100, 100));
   DrawFrame();
 
-  // Show top controls
-  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  // Show browser controls
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
   LayerImpl* outer_viewport_scroll_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   int id = outer_viewport_scroll_layer->id();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), id + 2);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->test_properties()->is_container_for_fixed_position_layers = true;
 
   // scroll child to limit
   SetScrollOffsetDelta(child.get(), gfx::Vector2dF(0, 100.f));
   child_clip->test_properties()->AddChild(std::move(child));
   outer_viewport_scroll_layer->test_properties()->AddChild(
       std::move(child_clip));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
-  // Scroll 25px to hide top controls
+  // Scroll 25px to hide browser controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
-  // Top controls should be hidden
+  // Browser controls should be hidden
   EXPECT_EQ(scroll_delta.y(),
             top_controls_height_ -
-                host_impl_->top_controls_manager()->ContentTopOffset());
+                host_impl_->browser_controls_manager()->ContentTopOffset());
 }
 
-// Ensure setting the top controls position explicitly using the setters on the
-// TreeImpl correctly affects the top controls manager and viewport bounds.
-TEST_F(LayerTreeHostImplTopControlsTest, PositionTopControlsExplicitly) {
+// Ensure setting the browser controls position explicitly using the setters on
+// the TreeImpl correctly affects the browser controls manager and viewport
+// bounds.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       PositionBrowserControlsExplicitly) {
   settings_ = DefaultSettings();
   CreateHostImpl(settings_, CreateCompositorFrameSink());
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       layer_size_, layer_size_, layer_size_);
   DrawFrame();
 
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(0.f);
   host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
       30.f / top_controls_height_);
   host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
-  EXPECT_FLOAT_EQ(30.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(30.f,
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(-20.f,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
 
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
-  EXPECT_FLOAT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(0.f);
+  EXPECT_FLOAT_EQ(0.f,
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(-50.f,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
 
-  host_impl_->DidChangeTopControlsPosition();
+  host_impl_->DidChangeBrowserControlsPosition();
 
-  // Now that top controls have moved, expect the clip to resize.
+  // Now that browser controls have moved, expect the clip to resize.
   LayerImpl* inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                                   ->test_properties()
                                   ->parent->test_properties()
                                   ->parent;
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
 }
 
 // Test that the top_controls delta and sent delta are appropriately
-// applied on sync tree activation. The total top controls offset shouldn't
+// applied on sync tree activation. The total browser controls offset shouldn't
 // change after the activation.
-TEST_F(LayerTreeHostImplTopControlsTest, ApplyDeltaOnTreeActivation) {
+TEST_F(LayerTreeHostImplBrowserControlsTest, ApplyDeltaOnTreeActivation) {
   settings_ = DefaultSettings();
   CreateHostImpl(settings_, CreateCompositorFrameSink());
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       layer_size_, layer_size_, layer_size_);
   DrawFrame();
 
   host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
       20.f / top_controls_height_);
   host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(
       15.f / top_controls_height_);
   host_impl_->active_tree()
       ->top_controls_shown_ratio()
       ->PullDeltaForMainThread();
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
-  host_impl_->sync_tree()->PushTopControlsFromMainThread(15.f /
-                                                         top_controls_height_);
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(0.f);
+  host_impl_->sync_tree()->PushBrowserControlsFromMainThread(
+      15.f / top_controls_height_);
 
-  host_impl_->DidChangeTopControlsPosition();
+  host_impl_->DidChangeBrowserControlsPosition();
   LayerImpl* inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                                   ->test_properties()
                                   ->parent->test_properties()
                                   ->parent;
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
 
   host_impl_->ActivateSyncTree();
 
   inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                        ->test_properties()
                        ->parent->test_properties()
                        ->parent;
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
 
   EXPECT_FLOAT_EQ(
       -15.f, host_impl_->active_tree()->top_controls_shown_ratio()->Delta() *
                  top_controls_height_);
   EXPECT_FLOAT_EQ(
       15.f,
       host_impl_->active_tree()->top_controls_shown_ratio()->ActiveBase() *
           top_controls_height_);
 }
 
-// Test that changing the top controls layout height is correctly applied to
-// the inner viewport container bounds. That is, the top controls layout
+// Test that changing the browser controls layout height is correctly applied to
+// the inner viewport container bounds. That is, the browser controls layout
 // height is the amount that the inner viewport container was shrunk outside
-// the compositor to accommodate the top controls.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsLayoutHeightChanged) {
+// the compositor to accommodate the browser controls.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       BrowserControlsLayoutHeightChanged) {
   settings_ = DefaultSettings();
   CreateHostImpl(settings_, CreateCompositorFrameSink());
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       layer_size_, layer_size_, layer_size_);
   DrawFrame();
 
-  host_impl_->sync_tree()->PushTopControlsFromMainThread(1.f);
-  host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
+  host_impl_->sync_tree()->PushBrowserControlsFromMainThread(1.f);
+  host_impl_->sync_tree()->set_browser_controls_shrink_blink_size(true);
 
   host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
       1.f);
   host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(0.f);
 
-  host_impl_->DidChangeTopControlsPosition();
+  host_impl_->DidChangeBrowserControlsPosition();
   LayerImpl* inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                                   ->test_properties()
                                   ->parent->test_properties()
                                   ->parent;
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
 
   host_impl_->sync_tree()->root_layer_for_testing()->SetBounds(
       gfx::Size(inner_clip_ptr->bounds().width(),
                 inner_clip_ptr->bounds().height() - 50.f));
 
   host_impl_->ActivateSyncTree();
 
   inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                        ->test_properties()
                        ->parent->test_properties()
                        ->parent;
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
 
   // The total bounds should remain unchanged since the bounds delta should
   // account for the difference between the layout height and the current
-  // top controls offset.
+  // browser controls offset.
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0.f, 50.f), inner_clip_ptr->bounds_delta());
 
-  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
-  host_impl_->DidChangeTopControlsPosition();
+  host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(1.f);
+  host_impl_->DidChangeBrowserControlsPosition();
 
-  EXPECT_EQ(1.f, host_impl_->top_controls_manager()->TopControlsShownRatio());
-  EXPECT_EQ(50.f, host_impl_->top_controls_manager()->TopControlsHeight());
-  EXPECT_EQ(50.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(1.f,
+            host_impl_->browser_controls_manager()->TopControlsShownRatio());
+  EXPECT_EQ(50.f, host_impl_->browser_controls_manager()->TopControlsHeight());
+  EXPECT_EQ(50.f, host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0.f, 0.f), inner_clip_ptr->bounds_delta());
   EXPECT_EQ(gfx::Size(viewport_size_.width(), viewport_size_.height() - 50.f),
             inner_clip_ptr->bounds());
 }
 
-// Test that showing/hiding the top controls when the viewport is fully scrolled
-// doesn't incorrectly change the viewport offset due to clamping from changing
-// viewport bounds.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsViewportOffsetClamping) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// Test that showing/hiding the browser controls when the viewport is fully
+// scrolled doesn't incorrectly change the viewport offset due to clamping from
+// changing viewport bounds.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       BrowserControlsViewportOffsetClamping) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
-  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   // Scroll the viewports to max scroll offset.
   SetScrollOffsetDelta(outer_scroll, gfx::Vector2dF(0, 200.f));
   SetScrollOffsetDelta(inner_scroll, gfx::Vector2dF(100, 100.f));
 
   gfx::ScrollOffset viewport_offset =
       host_impl_->active_tree()->TotalScrollOffset();
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(), viewport_offset);
 
-  // Hide the top controls by 25px.
+  // Hide the browser controls by 25px.
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
-  // scrolling down at the max extents no longer hides the top controls
-  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  // scrolling down at the max extents no longer hides the browser controls
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
-  // forcefully hide the top controls by 25px
-  host_impl_->top_controls_manager()->ScrollBy(scroll_delta);
+  // forcefully hide the browser controls by 25px
+  host_impl_->browser_controls_manager()->ScrollBy(scroll_delta);
   host_impl_->ScrollEnd(EndState().get());
 
-  EXPECT_FLOAT_EQ(scroll_delta.y(),
-                  top_controls_height_ -
-                      host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(
+      scroll_delta.y(),
+      top_controls_height_ -
+          host_impl_->browser_controls_manager()->ContentTopOffset());
 
   inner_scroll->ClampScrollToMaxScrollOffset();
   outer_scroll->ClampScrollToMaxScrollOffset();
 
   // We should still be fully scrolled.
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 
   viewport_offset = host_impl_->active_tree()->TotalScrollOffset();
 
-  // Bring the top controls down by 25px.
+  // Bring the browser controls down by 25px.
   scroll_delta = gfx::Vector2dF(0.f, -25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
   // The viewport offset shouldn't have changed.
   EXPECT_EQ(viewport_offset,
             host_impl_->active_tree()->TotalScrollOffset());
 
   // Scroll the viewports to max scroll offset.
   SetScrollOffsetDelta(outer_scroll, gfx::Vector2dF(0, 200.f));
   SetScrollOffsetDelta(inner_scroll, gfx::Vector2dF(100, 100.f));
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 }
 
-// Test that the top controls coming in and out maintains the same aspect ratio
-// between the inner and outer viewports.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsAspectRatio) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// Test that the browser controls coming in and out maintains the same aspect
+// ratio between the inner and outer viewports.
+TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsAspectRatio) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 2.f);
   DrawFrame();
 
   EXPECT_FLOAT_EQ(top_controls_height_,
-                  host_impl_->top_controls_manager()->ContentTopOffset());
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
 
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
   host_impl_->ScrollEnd(EndState().get());
 
-  EXPECT_FLOAT_EQ(scroll_delta.y(),
-                  top_controls_height_ -
-                      host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(
+      scroll_delta.y(),
+      top_controls_height_ -
+          host_impl_->browser_controls_manager()->ContentTopOffset());
 
-  // Top controls were hidden by 25px so the inner viewport should have expanded
-  // by that much.
+  // Browser controls were hidden by 25px so the inner viewport should have
+  // expanded by that much.
   LayerImpl* outer_container =
             host_impl_->active_tree()->OuterViewportContainerLayer();
   LayerImpl* inner_container =
             host_impl_->active_tree()->InnerViewportContainerLayer();
   EXPECT_EQ(gfx::SizeF(100.f, 100.f + 25.f),
             inner_container->BoundsForScrolling());
 
   // Outer viewport should match inner's aspect ratio. The bounds are ceiled.
   float aspect_ratio = inner_container->BoundsForScrolling().width() /
                        inner_container->BoundsForScrolling().height();
   gfx::SizeF expected =
       gfx::SizeF(gfx::ToCeiledSize(gfx::SizeF(200, 200 / aspect_ratio)));
   EXPECT_EQ(expected, outer_container->BoundsForScrolling());
   EXPECT_EQ(expected,
             host_impl_->InnerViewportScrollLayer()->BoundsForScrolling());
 }
 
-// Test that scrolling the outer viewport affects the top controls.
-TEST_F(LayerTreeHostImplTopControlsTest, TopControlsScrollOuterViewport) {
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+// Test that scrolling the outer viewport affects the browser controls.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       BrowserControlsScrollOuterViewport) {
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
   EXPECT_EQ(top_controls_height_,
-            host_impl_->top_controls_manager()->ContentTopOffset());
+            host_impl_->browser_controls_manager()->ContentTopOffset());
 
   // Send a gesture scroll that will scroll the outer viewport, make sure the
-  // top controls get scrolled.
+  // browser controls get scrolled.
   gfx::Vector2dF scroll_delta(0.f, 15.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
   host_impl_->ScrollEnd(EndState().get());
 
-  EXPECT_FLOAT_EQ(scroll_delta.y(),
-                  top_controls_height_ -
-                      host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(
+      scroll_delta.y(),
+      top_controls_height_ -
+          host_impl_->browser_controls_manager()->ContentTopOffset());
 
   scroll_delta = gfx::Vector2dF(0.f, 50.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
 
   host_impl_->ScrollEnd(EndState().get());
 
   // Position the viewports such that the inner viewport will be scrolled.
   gfx::Vector2dF inner_viewport_offset(0.f, 25.f);
   SetScrollOffsetDelta(host_impl_->OuterViewportScrollLayer(),
                        gfx::Vector2dF());
   SetScrollOffsetDelta(host_impl_->InnerViewportScrollLayer(),
                        inner_viewport_offset);
 
   scroll_delta = gfx::Vector2dF(0.f, -65.f);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), scroll_delta).get());
 
   EXPECT_EQ(top_controls_height_,
-            host_impl_->top_controls_manager()->ContentTopOffset());
+            host_impl_->browser_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(
       inner_viewport_offset.y() + (scroll_delta.y() + top_controls_height_),
       ScrollDelta(host_impl_->InnerViewportScrollLayer()).y());
 
   host_impl_->ScrollEnd(EndState().get());
 }
 
-TEST_F(LayerTreeHostImplTopControlsTest,
-       ScrollNonScrollableRootWithTopControls) {
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       ScrollNonScrollableRootWithBrowserControls) {
   settings_ = DefaultSettings();
   CreateHostImpl(settings_, CreateCompositorFrameSink());
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  SetupBrowserControlsAndScrollLayerWithVirtualViewport(
       layer_size_, layer_size_, layer_size_);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 50.f));
-  host_impl_->top_controls_manager()->ScrollEnd();
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
-  // Now that top controls have moved, expect the clip to resize.
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 50.f));
+  host_impl_->browser_controls_manager()->ScrollEnd();
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ContentTopOffset());
+  // Now that browser controls have moved, expect the clip to resize.
   LayerImpl* inner_clip_ptr = host_impl_->InnerViewportScrollLayer()
                                   ->test_properties()
                                   ->parent->test_properties()
                                   ->parent;
   EXPECT_EQ(viewport_size_, inner_clip_ptr->bounds());
 
   host_impl_->ScrollEnd(EndState().get());
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 
   float scroll_increment_y = -25.f;
-  host_impl_->top_controls_manager()->ScrollBegin();
-  host_impl_->top_controls_manager()->ScrollBy(
+  host_impl_->browser_controls_manager()->ScrollBegin();
+  host_impl_->browser_controls_manager()->ScrollBy(
       gfx::Vector2dF(0.f, scroll_increment_y));
   EXPECT_FLOAT_EQ(-scroll_increment_y,
-                  host_impl_->top_controls_manager()->ContentTopOffset());
-  // Now that top controls have moved, expect the clip to resize.
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
+  // Now that browser controls have moved, expect the clip to resize.
   EXPECT_EQ(gfx::Size(viewport_size_.width(),
                       viewport_size_.height() + scroll_increment_y),
             inner_clip_ptr->bounds());
 
-  host_impl_->top_controls_manager()->ScrollBy(
+  host_impl_->browser_controls_manager()->ScrollBy(
       gfx::Vector2dF(0.f, scroll_increment_y));
-  host_impl_->top_controls_manager()->ScrollEnd();
+  host_impl_->browser_controls_manager()->ScrollEnd();
   EXPECT_FLOAT_EQ(-2 * scroll_increment_y,
-                  host_impl_->top_controls_manager()->ContentTopOffset());
-  // Now that top controls have moved, expect the clip to resize.
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
+  // Now that browser controls have moved, expect the clip to resize.
   EXPECT_EQ(clip_size_, inner_clip_ptr->bounds());
 
   host_impl_->ScrollEnd(EndState().get());
 
   // Verify the layer is once-again non-scrollable.
   EXPECT_EQ(
       gfx::ScrollOffset(),
       host_impl_->active_tree()->InnerViewportScrollLayer()->MaxScrollOffset());
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
 }
 
 // Tests that activating a pending tree while there's a bounds_delta on the
-// viewport layers from top controls doesn't cause a scroll jump. This bug was
-// occurring because the UpdateViewportContainerSizes was being called before
-// the property trees were updated with the bounds_delta. crbug.com/597266.
-TEST_F(LayerTreeHostImplTopControlsTest, ViewportBoundsDeltaOnTreeActivation) {
+// viewport layers from browser controls doesn't cause a scroll jump. This bug
+// was occurring because the UpdateViewportContainerSizes was being called
+// before the property trees were updated with the bounds_delta.
+// crbug.com/597266.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       ViewportBoundsDeltaOnTreeActivation) {
   const gfx::Size inner_viewport_size(1000, 1000);
   const gfx::Size outer_viewport_size(1000, 1000);
   const gfx::Size content_size(2000, 2000);
 
   // Initialization
   {
-    SetupTopControlsAndScrollLayerWithVirtualViewport(
+    SetupBrowserControlsAndScrollLayerWithVirtualViewport(
         inner_viewport_size, outer_viewport_size, content_size);
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
 
-    // Start off with the top controls hidden on both main and impl.
-    host_impl_->active_tree()->set_top_controls_shrink_blink_size(false);
-    host_impl_->active_tree()->PushTopControlsFromMainThread(0);
+    // Start off with the browser controls hidden on both main and impl.
+    host_impl_->active_tree()->set_browser_controls_shrink_blink_size(false);
+    host_impl_->active_tree()->PushBrowserControlsFromMainThread(0);
 
     host_impl_->CreatePendingTree();
-    SetupTopControlsAndScrollLayerWithVirtualViewport(
+    SetupBrowserControlsAndScrollLayerWithVirtualViewport(
         host_impl_->pending_tree(), inner_viewport_size, outer_viewport_size,
         content_size);
-    host_impl_->pending_tree()->set_top_controls_shrink_blink_size(false);
+    host_impl_->pending_tree()->set_browser_controls_shrink_blink_size(false);
 
     // Fully scroll the viewport.
     host_impl_->ScrollBegin(BeginState(gfx::Point(75, 75)).get(),
                             InputHandler::TOUCHSCREEN);
     host_impl_->ScrollBy(
         UpdateState(gfx::Point(), gfx::Vector2d(0, 2000)).get());
     host_impl_->ScrollEnd(EndState().get());
   }
 
   LayerImpl* outer_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
 
-  ASSERT_FLOAT_EQ(0, host_impl_->top_controls_manager()->ContentTopOffset());
+  ASSERT_FLOAT_EQ(0,
+                  host_impl_->browser_controls_manager()->ContentTopOffset());
   ASSERT_EQ(1000, outer_scroll->MaxScrollOffset().y());
   ASSERT_EQ(1000, outer_scroll->CurrentScrollOffset().y());
 
-  // Kick off an animation to show the top controls.
-  host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN, true);
+  // Kick off an animation to show the browser controls.
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
+      BOTH, SHOWN, true);
   base::TimeTicks start_time = base::TimeTicks::Now();
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
 
-  // Pump an animation frame to put some delta in the top controls.
+  // Pump an animation frame to put some delta in the browser controls.
   {
     begin_frame_args.frame_time =
         start_time + base::TimeDelta::FromMilliseconds(50);
     host_impl_->WillBeginImplFrame(begin_frame_args);
     host_impl_->Animate();
     host_impl_->UpdateAnimationState(true);
     host_impl_->DidFinishImplFrame();
   }
 
-  // Pull the top controls delta and get it back to the pending tree so that
-  // when we go to activate the pending tree we cause a change to top controls.
+  // Pull the browser controls delta and get it back to the pending tree so that
+  // when we go to activate the pending tree we cause a change to browser
+  // controls.
   {
     float delta =
         host_impl_->active_tree()->top_controls_shown_ratio()->Delta();
     ASSERT_GT(delta, 0);
     ASSERT_LT(delta, 1);
     host_impl_->active_tree()
         ->top_controls_shown_ratio()
         ->PullDeltaForMainThread();
     host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
         delta);
   }
 
-  // 200 is the kShowHideMaxDurationMs value from top_controls_manager.cc so the
-  // top controls should be fully animated in this frame.
+  // 200 is the kShowHideMaxDurationMs value from browser_controls_manager.cc so
+  // the browser controls should be fully animated in this frame.
   {
     begin_frame_args.frame_time =
         start_time + base::TimeDelta::FromMilliseconds(200);
     host_impl_->WillBeginImplFrame(begin_frame_args);
     host_impl_->Animate();
     host_impl_->UpdateAnimationState(true);
     host_impl_->DidFinishImplFrame();
 
-    ASSERT_EQ(50, host_impl_->top_controls_manager()->ContentTopOffset());
+    ASSERT_EQ(50, host_impl_->browser_controls_manager()->ContentTopOffset());
     ASSERT_EQ(1050, outer_scroll->MaxScrollOffset().y());
     // NEAR because clip layer bounds are truncated in MaxScrollOffset so we
     // lose some precision in the intermediate animation steps.
     ASSERT_NEAR(1050, outer_scroll->CurrentScrollOffset().y(), 1.f);
   }
 
   // Activate the pending tree which should have the same scroll value as the
   // active tree.
   {
     host_impl_->pending_tree()
@@ skipping 4064 matching lines @@
                       UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get())
             .did_scroll);
     host_impl_->ScrollEnd(EndState().get());
 
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
     EXPECT_EQ(1, forward_to_main_count);
   }
 }
 
-class LayerTreeHostImplWithTopControlsTest : public LayerTreeHostImplTest {
+class LayerTreeHostImplWithBrowserControlsTest : public LayerTreeHostImplTest {
  public:
   void SetUp() override {
     LayerTreeSettings settings = DefaultSettings();
     CreateHostImpl(settings, CreateCompositorFrameSink());
     host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
     host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
-    host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
+    host_impl_->active_tree()->SetCurrentBrowserControlsShownRatio(1.f);
   }
 
  protected:
   static const int top_controls_height_;
 };
 
-const int LayerTreeHostImplWithTopControlsTest::top_controls_height_ = 50;
+const int LayerTreeHostImplWithBrowserControlsTest::top_controls_height_ = 50;
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, NoIdleAnimations) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest, NoIdleAnimations) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   scroll_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
                                                      gfx::ScrollOffset(0, 10));
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->Animate();
   EXPECT_FALSE(did_request_redraw_);
   host_impl_->DidFinishImplFrame();
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsHeightIsCommitted) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsHeightIsCommitted) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_FALSE(did_request_redraw_);
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(100);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(100, host_impl_->top_controls_manager()->TopControlsHeight());
+  EXPECT_EQ(100, host_impl_->browser_controls_manager()->TopControlsHeight());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest,
-       TopControlsStayFullyVisibleOnHeightChange) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsStayFullyVisibleOnHeightChange) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ControlsTopOffset());
 
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(0);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ControlsTopOffset());
 
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(50);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->browser_controls_manager()->ControlsTopOffset());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationScheduling) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsAnimationScheduling) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   scroll_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer->id(),
                                                      gfx::ScrollOffset(0, 10));
-  host_impl_->DidChangeTopControlsPosition();
+  host_impl_->DidChangeBrowserControlsPosition();
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, ScrollHandledByTopControls) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       ScrollHandledByBrowserControls) {
   InputHandlerScrollResult result;
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
-  host_impl_->top_controls_manager()->UpdateTopControlsState(
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
       BOTH, SHOWN, false);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // Scroll just the top controls and verify that the scroll succeeds.
+  // Scroll just the browser controls and verify that the scroll succeeds.
   const float residue = 10;
   float offset = top_controls_height_ - residue;
   result = host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get());
   EXPECT_EQ(result.unused_scroll_delta, gfx::Vector2d(0, 0));
   EXPECT_TRUE(result.did_scroll);
   EXPECT_FLOAT_EQ(-offset,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll across the boundary
   const float content_scroll = 20;
   offset = residue + content_scroll;
   result = host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get());
   EXPECT_TRUE(result.did_scroll);
   EXPECT_EQ(result.unused_scroll_delta, gfx::Vector2d(0, 0));
   EXPECT_EQ(-top_controls_height_,
-            host_impl_->top_controls_manager()->ControlsTopOffset());
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, content_scroll).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Now scroll back to the top of the content
   offset = -content_scroll;
   result = host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get());
   EXPECT_TRUE(result.did_scroll);
   EXPECT_EQ(result.unused_scroll_delta, gfx::Vector2d(0, 0));
   EXPECT_EQ(-top_controls_height_,
-            host_impl_->top_controls_manager()->ControlsTopOffset());
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // And scroll the top controls completely into view
+  // And scroll the browser controls completely into view
   offset = -top_controls_height_;
   result = host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get());
   EXPECT_TRUE(result.did_scroll);
   EXPECT_EQ(result.unused_scroll_delta, gfx::Vector2d(0, 0));
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // And attempt to scroll past the end
   result = host_impl_->ScrollBy(
       UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get());
   EXPECT_FALSE(result.did_scroll);
   EXPECT_EQ(result.unused_scroll_delta, gfx::Vector2d(0, -50));
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   host_impl_->ScrollEnd(EndState().get());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, WheelUnhandledByTopControls) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       WheelUnhandledByBrowserControls) {
   SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(50, 100));
-  host_impl_->active_tree()->set_top_controls_shrink_blink_size(true);
-  host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
-                                                             false);
+  host_impl_->active_tree()->set_browser_controls_shrink_blink_size(true);
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
+      BOTH, SHOWN, false);
   DrawFrame();
 
   LayerImpl* viewport_layer = host_impl_->InnerViewportScrollLayer();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), viewport_layer->CurrentScrollOffset());
 
-  // Wheel scrolls should not affect the top controls, and should pass
+  // Wheel scrolls should not affect the browser controls, and should pass
   // directly through to the viewport.
   const float delta = top_controls_height_;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, delta)).get())
           .did_scroll);
-  EXPECT_FLOAT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_FLOAT_EQ(0,
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, delta),
                    viewport_layer->CurrentScrollOffset());
 
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, delta)).get())
           .did_scroll);
-  EXPECT_FLOAT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_FLOAT_EQ(0,
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, delta * 2),
                    viewport_layer->CurrentScrollOffset());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationAtOrigin) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsAnimationAtOrigin) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(gfx::Size(100, 200));
-  host_impl_->top_controls_manager()->UpdateTopControlsState(
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
       BOTH, SHOWN, false);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // Scroll the top controls partially.
+  // Scroll the browser controls partially.
   const float residue = 35;
   float offset = top_controls_height_ - residue;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
           .did_scroll);
   EXPECT_FLOAT_EQ(-offset,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_next_frame_ = false;
   did_request_commit_ = false;
 
   // End the scroll while the controls are still offset from their limit.
   host_impl_->ScrollEnd(EndState().get());
-  ASSERT_TRUE(host_impl_->top_controls_manager()->has_animation());
+  ASSERT_TRUE(host_impl_->browser_controls_manager()->has_animation());
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
-  // The top controls should properly animate until finished, despite the scroll
-  // offset being at the origin.
+  // The browser controls should properly animate until finished, despite the
+  // scroll offset being at the origin.
   BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_next_frame_) {
     did_request_redraw_ = false;
     did_request_next_frame_ = false;
     did_request_commit_ = false;
 
     float old_offset =
-        host_impl_->top_controls_manager()->ControlsTopOffset();
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
     host_impl_->WillBeginImplFrame(begin_frame_args);
     host_impl_->Animate();
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               scroll_layer->CurrentScrollOffset().ToString());
 
     float new_offset =
-        host_impl_->top_controls_manager()->ControlsTopOffset();
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     // No commit is needed as the controls are animating the content offset,
     // not the scroll offset.
     EXPECT_FALSE(did_request_commit_);
 
     if (new_offset != old_offset)
       EXPECT_TRUE(did_request_redraw_);
 
     if (new_offset != 0) {
-      EXPECT_TRUE(host_impl_->top_controls_manager()->has_animation());
+      EXPECT_TRUE(host_impl_->browser_controls_manager()->has_animation());
       EXPECT_TRUE(did_request_next_frame_);
     }
     host_impl_->DidFinishImplFrame();
   }
-  EXPECT_FALSE(host_impl_->top_controls_manager()->has_animation());
+  EXPECT_FALSE(host_impl_->browser_controls_manager()->has_animation());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationAfterScroll) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsAnimationAfterScroll) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
-  host_impl_->top_controls_manager()->UpdateTopControlsState(
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
       BOTH, SHOWN, false);
   float initial_scroll_offset = 50;
   scroll_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(
           scroll_layer->id(), gfx::ScrollOffset(0, initial_scroll_offset));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // Scroll the top controls partially.
+  // Scroll the browser controls partially.
   const float residue = 15;
   float offset = top_controls_height_ - residue;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
           .did_scroll);
   EXPECT_FLOAT_EQ(-offset,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_next_frame_ = false;
   did_request_commit_ = false;
 
   // End the scroll while the controls are still offset from the limit.
   host_impl_->ScrollEnd(EndState().get());
-  ASSERT_TRUE(host_impl_->top_controls_manager()->has_animation());
+  ASSERT_TRUE(host_impl_->browser_controls_manager()->has_animation());
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
-  // Animate the top controls to the limit.
+  // Animate the browser controls to the limit.
   BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_next_frame_) {
     did_request_redraw_ = false;
     did_request_next_frame_ = false;
     did_request_commit_ = false;
 
     float old_offset =
-        host_impl_->top_controls_manager()->ControlsTopOffset();
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
     host_impl_->WillBeginImplFrame(begin_frame_args);
     host_impl_->Animate();
 
     float new_offset =
-        host_impl_->top_controls_manager()->ControlsTopOffset();
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     if (new_offset != old_offset) {
       EXPECT_TRUE(did_request_redraw_);
       EXPECT_TRUE(did_request_commit_);
     }
     host_impl_->DidFinishImplFrame();
   }
-  EXPECT_FALSE(host_impl_->top_controls_manager()->has_animation());
+  EXPECT_FALSE(host_impl_->browser_controls_manager()->has_animation());
   EXPECT_EQ(-top_controls_height_,
-            host_impl_->top_controls_manager()->ControlsTopOffset());
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest,
-       TopControlsAnimationAfterMainThreadFlingStopped) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsAnimationAfterMainThreadFlingStopped) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
-  host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
-                                                             false);
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
+      BOTH, SHOWN, false);
   float initial_scroll_offset = 50;
   scroll_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(
           scroll_layer->id(), gfx::ScrollOffset(0, initial_scroll_offset));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // Scroll the top controls partially.
+  // Scroll the browser controls partially.
   const float residue = 15;
   float offset = top_controls_height_ - residue;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
           .did_scroll);
   EXPECT_FLOAT_EQ(-offset,
-                  host_impl_->top_controls_manager()->ControlsTopOffset());
+                  host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_next_frame_ = false;
   did_request_commit_ = false;
 
   // End the fling while the controls are still offset from the limit.
   host_impl_->MainThreadHasStoppedFlinging();
-  ASSERT_TRUE(host_impl_->top_controls_manager()->has_animation());
+  ASSERT_TRUE(host_impl_->browser_controls_manager()->has_animation());
   EXPECT_TRUE(did_request_next_frame_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
-  // Animate the top controls to the limit.
+  // Animate the browser controls to the limit.
   BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_next_frame_) {
     did_request_redraw_ = false;
     did_request_next_frame_ = false;
     did_request_commit_ = false;
 
-    float old_offset = host_impl_->top_controls_manager()->ControlsTopOffset();
+    float old_offset =
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
     host_impl_->WillBeginImplFrame(begin_frame_args);
     host_impl_->Animate();
 
-    float new_offset = host_impl_->top_controls_manager()->ControlsTopOffset();
+    float new_offset =
+        host_impl_->browser_controls_manager()->ControlsTopOffset();
 
     if (new_offset != old_offset) {
       EXPECT_TRUE(did_request_redraw_);
       EXPECT_TRUE(did_request_commit_);
     }
     host_impl_->DidFinishImplFrame();
   }
-  EXPECT_FALSE(host_impl_->top_controls_manager()->has_animation());
+  EXPECT_FALSE(host_impl_->browser_controls_manager()->has_animation());
   EXPECT_EQ(-top_controls_height_,
-            host_impl_->top_controls_manager()->ControlsTopOffset());
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
 }
 
-TEST_F(LayerTreeHostImplWithTopControlsTest,
-       TopControlsScrollDeltaInOverScroll) {
+TEST_F(LayerTreeHostImplWithBrowserControlsTest,
+       BrowserControlsScrollDeltaInOverScroll) {
   // Verifies that the overscroll delta should not have accumulated in
-  // the top controls if we do a hide and show without releasing finger.
+  // the browser controls if we do a hide and show without releasing finger.
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
-  host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
-                                                             false);
+  host_impl_->browser_controls_manager()->UpdateBrowserControlsState(
+      BOTH, SHOWN, false);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
 
   float offset = 50;
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
           .did_scroll);
-  EXPECT_EQ(-offset, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(-offset,
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, offset)).get())
           .did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
@@ skipping 18 matching lines @@
             scroll_layer->CurrentScrollOffset().ToString());
   EXPECT_EQ(gfx::Vector2dF(0, overscrollamount).ToString(),
             host_impl_->accumulated_root_overscroll().ToString());
 
   EXPECT_TRUE(host_impl_->ScrollBy(UpdateState(gfx::Point(),
                                                gfx::Vector2d(0, -2 * offset))
                                        .get())
                   .did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, 0).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
-  EXPECT_EQ(-offset, host_impl_->top_controls_manager()->ControlsTopOffset());
+  EXPECT_EQ(-offset,
+            host_impl_->browser_controls_manager()->ControlsTopOffset());
 
   EXPECT_TRUE(
       host_impl_->ScrollBy(
                     UpdateState(gfx::Point(), gfx::Vector2d(0, -offset)).get())
           .did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, 0).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  // Top controls should be fully visible
-  EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
+  // Browser controls should be fully visible
+  EXPECT_EQ(0, host_impl_->browser_controls_manager()->ControlsTopOffset());
 
   host_impl_->ScrollEnd(EndState().get());
 }
 
 // Tests that when we set a child scroller (e.g. a scrolling div) as the outer
-// viewport, scrolling it controls the top controls.
-TEST_F(LayerTreeHostImplTopControlsTest,
-       ReplacedOuterViewportScrollsTopControls) {
+// viewport, scrolling it controls the browser controls.
+TEST_F(LayerTreeHostImplBrowserControlsTest,
+       ReplacedOuterViewportScrollsBrowserControls) {
   const gfx::Size scroll_content_size(400, 400);
   const gfx::Size root_layer_size(200, 200);
   const gfx::Size viewport_size(100, 100);
 
-  SetupTopControlsAndScrollLayerWithVirtualViewport(
+  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;
 
   // 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.
@@ skipping 11 matching lines @@
 
     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(),
         inner_scroll->id(), scroll_layer->id());
     layer_tree_impl->BuildPropertyTreesForTesting();
     DrawFrame();
   }
 
-  ASSERT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+  ASSERT_EQ(1.f, host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
 
-  // Scrolling should scroll the child content and the top controls. The
+  // 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(),
                             InputHandler::TOUCHSCREEN);
     host_impl_->ScrollBy(
         UpdateState(gfx::Point(0, 0), gfx::Vector2dF(100.f, 100.f)).get());
     host_impl_->ScrollEnd(EndState().get());
 
     EXPECT_VECTOR_EQ(gfx::Vector2dF(), outer_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(gfx::Vector2dF(100.f, 50.f),
                      scroll_layer->CurrentScrollOffset());
-    EXPECT_EQ(0.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
+    EXPECT_EQ(0.f,
+              host_impl_->active_tree()->CurrentBrowserControlsShownRatio());
   }
 }
 
 class LayerTreeHostImplVirtualViewportTest : public LayerTreeHostImplTest {
  public:
   void SetupVirtualViewportLayers(const gfx::Size& content_size,
                                   const gfx::Size& outer_viewport,
                                   const gfx::Size& inner_viewport) {
     LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
     const int kOuterViewportClipLayerId = 6;
@@ skipping 2034 matching lines @@
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
   compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
   host_impl_->InitializeRenderer(compositor_frame_sink_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc