Views: Give ScrollViewTest a test harness.

ui/views/controls/scroll_view_unittest.cc

 // Copyright (c) 2012 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 "ui/views/controls/scroll_view.h"
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 114 matching lines @@
 
 ui::MouseEvent TestLeftMouseAt(const gfx::Point& location, ui::EventType type) {
   return ui::MouseEvent(type, location, location, base::TimeTicks(),
                         ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
 }
 
 }  // namespace
 
 using test::ScrollViewTestApi;
 
+// Simple test harness for testing a ScrollView directly.
+class ScrollViewTest : public testing::Test {
+ public:
+  ScrollViewTest() {}
+
+  View* InstallContents() {
+    const gfx::Rect default_outer_bounds(0, 0, 100, 100);
+    View* contents = new View;
+    scroll_view_.SetContents(contents);
+    scroll_view_.SetBoundsRect(default_outer_bounds);
+    return contents;
+  }
+
+ protected:
+#if defined(OS_MACOSX)
+  void SetOverlayScrollersEnabled(bool enabled) {
+    scroller_style_.reset();

[sky, 2016/10/24 16:09:49]

It's worth a comment as to why you need two resets rather than one.

[tapted, 2016/10/25 02:44:12]

Done.

+    scroller_style_.reset(new ui::test::ScopedPreferredScrollerStyle(enabled));

[sky, 2016/10/24 16:09:49]

MakeUnique?

[tapted, 2016/10/25 02:44:12]

Done. There's actually a way to omit the template arguments with a weird C++
trick. I.e. instead of

scroller_style_ =
base::MakeUnique<ui::test::ScopedPreferredScrollerStyle>(true);

it could be

scroller_style_ = base::EmplaceUnique(true);

But it's probably too much C++ voodoo (CL for it looks like
https://codereview.chromium.org/2449753002 ).

+  }
+
+ private:
+  // Disable overlay scrollers by default. This needs to be set before
+  // |scroll_view_| is initialized, otherwise scrollers will try to animate to
+  // change modes, which requires a MessageLoop to exist. Tests should only

[tapted, 2016/10/24 06:50:51]

It's possible that later on I'll need a MessageLoop.. (or I'll need to migrate
tests to use WidgetScrollViewTest just below). But the existing tests were
getting weird failures in the next round of things because of this other
strangeness.

+  // modify this via SetOverlayScrollersEnabled().
+  std::unique_ptr<ui::test::ScopedPreferredScrollerStyle> scroller_style_ =
+      base::MakeUnique<ui::test::ScopedPreferredScrollerStyle>(false);
+
+ protected:
+#endif
+  ScrollView scroll_view_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScrollViewTest);
+};
+
 // Test harness that includes a Widget to help test ui::Event handling.
 class WidgetScrollViewTest : public test::WidgetTest,
                              public ui::CompositorObserver {
  public:
   static const int kDefaultHeight = 100;
   static const int kDefaultWidth = 100;
 
   WidgetScrollViewTest() {
 #if defined(OS_MACOSX)
     // Disable scrollbar hiding (i.e. disable overlay scrollbars) by default.
@@ skipping 81 matching lines @@
   std::unique_ptr<ui::test::ScopedPreferredScrollerStyle> scroller_style_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(WidgetScrollViewTest);
 };
 
 const int WidgetScrollViewTest::kDefaultHeight;
 const int WidgetScrollViewTest::kDefaultWidth;
 
 // Verifies the viewport is sized to fit the available space.
-TEST(ScrollViewTest, ViewportSizedToFit) {
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  scroll_view.Layout();
+TEST_F(ScrollViewTest, ViewportSizedToFit) {
+  View* contents = InstallContents();
+  scroll_view_.Layout();
   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
 }
 
 // Verifies the viewport and content is sized to fit the available space for
 // bounded scroll view.
-TEST(ScrollViewTest, BoundedViewportSizedToFit) {
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
-  scroll_view.ClipHeightTo(100, 200);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  scroll_view.SetBorder(Border::CreateSolidBorder(2, 0));
-  scroll_view.Layout();
+TEST_F(ScrollViewTest, BoundedViewportSizedToFit) {
+  View* contents = InstallContents();
+  scroll_view_.ClipHeightTo(100, 200);
+  scroll_view_.SetBorder(Border::CreateSolidBorder(2, 0));
+  scroll_view_.Layout();
   EXPECT_EQ("2,2 96x96", contents->parent()->bounds().ToString());
 
   // Make sure the width of |contents| is set properly not to overflow the
   // viewport.
   EXPECT_EQ(96, contents->width());
 }
 
 // Verifies the scrollbars are added as necessary.
 // If on Mac, test the non-overlay scrollbars.
-TEST(ScrollViewTest, ScrollBars) {
-#if defined(OS_MACOSX)
-  ui::test::ScopedPreferredScrollerStyle scroller_style_override(false);
-#endif
-
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
+TEST_F(ScrollViewTest, ScrollBars) {
+  View* contents = InstallContents();
 
   // Size the contents such that vertical scrollbar is needed.
   contents->SetBounds(0, 0, 50, 400);
-  scroll_view.Layout();
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
+  scroll_view_.Layout();
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+            contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, true);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, false);
-  EXPECT_TRUE(!scroll_view.horizontal_scroll_bar() ||
-              !scroll_view.horizontal_scroll_bar()->visible());
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, false);
+  EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
+              !scroll_view_.horizontal_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarHeight(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
             contents->parent()->height());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, false);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, true);
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, false);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Both horizontal and vertical.
   contents->SetBounds(0, 0, 300, 400);
-  scroll_view.Layout();
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarHeight(),
+  scroll_view_.Layout();
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+            contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
             contents->parent()->height());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, true);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, true);
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Add a border, test vertical scrollbar.
   const int kTopPadding = 1;
   const int kLeftPadding = 2;
   const int kBottomPadding = 3;
   const int kRightPadding = 4;
-  scroll_view.SetBorder(Border::CreateEmptyBorder(
+  scroll_view_.SetBorder(Border::CreateEmptyBorder(
       kTopPadding, kLeftPadding, kBottomPadding, kRightPadding));
   contents->SetBounds(0, 0, 50, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(
-      100 - scroll_view.GetScrollBarWidth() - kLeftPadding - kRightPadding,
+      100 - scroll_view_.GetScrollBarWidth() - kLeftPadding - kRightPadding,
       contents->parent()->width());
   EXPECT_EQ(100 - kTopPadding - kBottomPadding, contents->parent()->height());
-  EXPECT_TRUE(!scroll_view.horizontal_scroll_bar() ||
-              !scroll_view.horizontal_scroll_bar()->visible());
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
-  gfx::Rect bounds = scroll_view.vertical_scroll_bar()->bounds();
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth() - kRightPadding, bounds.x());
+  EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
+              !scroll_view_.horizontal_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
+  gfx::Rect bounds = scroll_view_.vertical_scroll_bar()->bounds();
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth() - kRightPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
   EXPECT_EQ(kTopPadding, bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
 
   // Horizontal with border.
   contents->SetBounds(0, 0, 400, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(100 - kLeftPadding - kRightPadding, contents->parent()->width());
   EXPECT_EQ(
-      100 - scroll_view.GetScrollBarHeight() - kTopPadding - kBottomPadding,
+      100 - scroll_view_.GetScrollBarHeight() - kTopPadding - kBottomPadding,
       contents->parent()->height());
-  ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
-  EXPECT_TRUE(!scroll_view.vertical_scroll_bar() ||
-              !scroll_view.vertical_scroll_bar()->visible());
-  bounds = scroll_view.horizontal_scroll_bar()->bounds();
+  ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
+  EXPECT_TRUE(!scroll_view_.vertical_scroll_bar() ||
+              !scroll_view_.vertical_scroll_bar()->visible());
+  bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(kLeftPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view.GetScrollBarHeight(),
+  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
             bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
 
   // Both horizontal and vertical with border.
   contents->SetBounds(0, 0, 300, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(
-      100 - scroll_view.GetScrollBarWidth() - kLeftPadding - kRightPadding,
+      100 - scroll_view_.GetScrollBarWidth() - kLeftPadding - kRightPadding,
       contents->parent()->width());
   EXPECT_EQ(
-      100 - scroll_view.GetScrollBarHeight() - kTopPadding - kBottomPadding,
+      100 - scroll_view_.GetScrollBarHeight() - kTopPadding - kBottomPadding,
       contents->parent()->height());
-  bounds = scroll_view.horizontal_scroll_bar()->bounds();
+  bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   // Check horiz.
-  ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
-  bounds = scroll_view.horizontal_scroll_bar()->bounds();
+  ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
+  bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(kLeftPadding, bounds.x());
-  EXPECT_EQ(100 - kRightPadding - scroll_view.GetScrollBarWidth(),
+  EXPECT_EQ(100 - kRightPadding - scroll_view_.GetScrollBarWidth(),
             bounds.right());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view.GetScrollBarHeight(),
+  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
             bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
   // Check vert.
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
-  bounds = scroll_view.vertical_scroll_bar()->bounds();
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth() - kRightPadding, bounds.x());
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
+  bounds = scroll_view_.vertical_scroll_bar()->bounds();
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth() - kRightPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
   EXPECT_EQ(kTopPadding, bounds.y());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view.GetScrollBarHeight(),
+  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
             bounds.bottom());
 }
 
 // Assertions around adding a header.
-TEST(ScrollViewTest, Header) {
-  ScrollView scroll_view;
-  View* contents = new View;
+TEST_F(ScrollViewTest, Header) {
   CustomView* header = new CustomView;
-  scroll_view.SetHeader(header);
+  scroll_view_.SetHeader(header);
   View* header_parent = header->parent();
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  scroll_view.Layout();
+  View* contents = InstallContents();
+
+  scroll_view_.Layout();
   // |header|s preferred size is empty, which should result in all space going
   // to contents.
   EXPECT_EQ("0,0 100x0", header->parent()->bounds().ToString());
   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
 
   // With layered scrolling, ScrollView::Layout() will impose a size on the
   // contents that fills the viewport. Since the test view doesn't have its own
   // Layout, reset it in this case so that adding a header doesn't shift the
   // contents down and require scrollbars.
   if (contents->layer()) {
     EXPECT_EQ("0,0 100x100", contents->bounds().ToString());
     contents->SetBoundsRect(gfx::Rect());
   }
   EXPECT_EQ("0,0 0x0", contents->bounds().ToString());
 
   // Get the header a height of 20.
   header->SetPreferredSize(gfx::Size(10, 20));
   EXPECT_EQ("0,0 100x20", header->parent()->bounds().ToString());
   EXPECT_EQ("0,20 100x80", contents->parent()->bounds().ToString());
   if (contents->layer()) {
     EXPECT_EQ("0,0 100x80", contents->bounds().ToString());
     contents->SetBoundsRect(gfx::Rect());
   }
   EXPECT_EQ("0,0 0x0", contents->bounds().ToString());
 
   // Remove the header.
-  scroll_view.SetHeader(NULL);
+  scroll_view_.SetHeader(NULL);
   // SetHeader(NULL) deletes header.
   header = NULL;
   EXPECT_EQ("0,0 100x0", header_parent->bounds().ToString());
   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
 }
 
 // Verifies the scrollbars are added as necessary when a header is present.
-TEST(ScrollViewTest, ScrollBarsWithHeader) {
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
+TEST_F(ScrollViewTest, ScrollBarsWithHeader) {
   CustomView* header = new CustomView;
-  scroll_view.SetHeader(header);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
+  scroll_view_.SetHeader(header);
+  View* contents = InstallContents();
 
   header->SetPreferredSize(gfx::Size(10, 20));
 
   // Size the contents such that vertical scrollbar is needed.
   contents->SetBounds(0, 0, 50, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+            contents->parent()->width());
   EXPECT_EQ(80, contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), header->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(), header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
-  EXPECT_TRUE(!scroll_view.horizontal_scroll_bar() ||
-              !scroll_view.horizontal_scroll_bar()->visible());
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
+  EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
+              !scroll_view_.horizontal_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
   // Make sure the vertical scrollbar overlaps the header.
-  EXPECT_EQ(header->y(), scroll_view.vertical_scroll_bar()->y());
+  EXPECT_EQ(header->y(), scroll_view_.vertical_scroll_bar()->y());
   EXPECT_EQ(header->y(), contents->y());
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
   EXPECT_EQ(100, contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarHeight() - 20,
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight() - 20,
             contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
   EXPECT_EQ(100, header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
-  ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
-  EXPECT_TRUE(!scroll_view.vertical_scroll_bar() ||
-              !scroll_view.vertical_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
+  EXPECT_TRUE(!scroll_view_.vertical_scroll_bar() ||
+              !scroll_view_.vertical_scroll_bar()->visible());
 
   // Both horizontal and vertical.
   contents->SetBounds(0, 0, 300, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarHeight() - 20,
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+            contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight() - 20,
             contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), header->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(), header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
-  ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
-  EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
+  EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
 }
 
 // Verifies the header scrolls horizontally with the content.
-TEST(ScrollViewTest, HeaderScrollsWithContent) {
-  ScrollView scroll_view;
-  ScrollViewTestApi test_api(&scroll_view);
+TEST_F(ScrollViewTest, HeaderScrollsWithContent) {
+  ScrollViewTestApi test_api(&scroll_view_);
   CustomView* contents = new CustomView;
-  scroll_view.SetContents(contents);
+  scroll_view_.SetContents(contents);
   contents->SetPreferredSize(gfx::Size(500, 500));
 
   CustomView* header = new CustomView;
-  scroll_view.SetHeader(header);
+  scroll_view_.SetHeader(header);
   header->SetPreferredSize(gfx::Size(500, 20));
 
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
+  scroll_view_.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
   EXPECT_EQ("0,0", test_api.IntegralViewOffset().ToString());
   EXPECT_EQ("0,0", header->bounds().origin().ToString());
 
   // Scroll the horizontal scrollbar.
-  ASSERT_TRUE(scroll_view.horizontal_scroll_bar());
-  scroll_view.ScrollToPosition(
-      const_cast<ScrollBar*>(scroll_view.horizontal_scroll_bar()), 1);
+  ASSERT_TRUE(scroll_view_.horizontal_scroll_bar());
+  scroll_view_.ScrollToPosition(
+      const_cast<ScrollBar*>(scroll_view_.horizontal_scroll_bar()), 1);
   EXPECT_EQ("-1,0", test_api.IntegralViewOffset().ToString());
   EXPECT_EQ("-1,0", header->bounds().origin().ToString());
 
   // Scrolling the vertical scrollbar shouldn't effect the header.
-  ASSERT_TRUE(scroll_view.vertical_scroll_bar());
-  scroll_view.ScrollToPosition(
-      const_cast<ScrollBar*>(scroll_view.vertical_scroll_bar()), 1);
+  ASSERT_TRUE(scroll_view_.vertical_scroll_bar());
+  scroll_view_.ScrollToPosition(
+      const_cast<ScrollBar*>(scroll_view_.vertical_scroll_bar()), 1);
   EXPECT_EQ("-1,-1", test_api.IntegralViewOffset().ToString());
   EXPECT_EQ("-1,0", header->bounds().origin().ToString());
 }
 
 // Verifies ScrollRectToVisible() on the child works.
-TEST(ScrollViewTest, ScrollRectToVisible) {
-#if defined(OS_MACOSX)
-  ui::test::ScopedPreferredScrollerStyle scroller_style_override(false);
-#endif
-  ScrollView scroll_view;
-  ScrollViewTestApi test_api(&scroll_view);
+TEST_F(ScrollViewTest, ScrollRectToVisible) {
+  ScrollViewTestApi test_api(&scroll_view_);
   CustomView* contents = new CustomView;
-  scroll_view.SetContents(contents);
+  scroll_view_.SetContents(contents);
   contents->SetPreferredSize(gfx::Size(500, 1000));
 
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  scroll_view.Layout();
+  scroll_view_.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
+  scroll_view_.Layout();
   EXPECT_EQ("0,0", test_api.IntegralViewOffset().ToString());
 
   // Scroll to y=405 height=10, this should make the y position of the content
   // at (405 + 10) - viewport_height (scroll region bottom aligned).
   contents->ScrollRectToVisible(gfx::Rect(0, 405, 10, 10));
   const int viewport_height = test_api.contents_viewport()->height();
 
   // Expect there to be a horizontal scrollbar, making the viewport shorter.
   EXPECT_LT(viewport_height, 100);
 
   gfx::ScrollOffset offset = test_api.CurrentOffset();
   EXPECT_EQ(415 - viewport_height, offset.y());
 
   // Scroll to the current y-location and 10x10; should do nothing.
   contents->ScrollRectToVisible(gfx::Rect(0, offset.y(), 10, 10));
   EXPECT_EQ(415 - viewport_height, test_api.CurrentOffset().y());
 }
 
 // Verifies ClipHeightTo() uses the height of the content when it is between the
 // minimum and maximum height values.
-TEST(ScrollViewTest, ClipHeightToNormalContentHeight) {
-  ScrollView scroll_view;
-
-  scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
+TEST_F(ScrollViewTest, ClipHeightToNormalContentHeight) {
+  scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   const int kNormalContentHeight = 75;
-  scroll_view.SetContents(
+  scroll_view_.SetContents(
       new views::StaticSizedView(gfx::Size(kWidth, kNormalContentHeight)));
 
   EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight),
-            scroll_view.GetPreferredSize());
+            scroll_view_.GetPreferredSize());
 
-  scroll_view.SizeToPreferredSize();
-  scroll_view.Layout();
+  scroll_view_.SizeToPreferredSize();
+  scroll_view_.Layout();
 
   EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight),
-            scroll_view.contents()->size());
-  EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight), scroll_view.size());
+            scroll_view_.contents()->size());
+  EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight), scroll_view_.size());
 }
 
 // Verifies ClipHeightTo() uses the minimum height when the content is shorter
 // than the minimum height value.
-TEST(ScrollViewTest, ClipHeightToShortContentHeight) {
-  ScrollView scroll_view;
-
-  scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
+TEST_F(ScrollViewTest, ClipHeightToShortContentHeight) {
+  scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   const int kShortContentHeight = 10;
   View* contents =
       new views::StaticSizedView(gfx::Size(kWidth, kShortContentHeight));
-  scroll_view.SetContents(contents);
+  scroll_view_.SetContents(contents);
 
-  EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view.GetPreferredSize());
+  EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view_.GetPreferredSize());
 
-  scroll_view.SizeToPreferredSize();
-  scroll_view.Layout();
+  scroll_view_.SizeToPreferredSize();
+  scroll_view_.Layout();
 
   // Layered scrolling requires the contents to fill the viewport.
   if (contents->layer()) {
-    EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view.contents()->size());
+    EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view_.contents()->size());
   } else {
     EXPECT_EQ(gfx::Size(kWidth, kShortContentHeight),
-              scroll_view.contents()->size());
+              scroll_view_.contents()->size());
   }
-  EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view.size());
+  EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view_.size());
 }
 
 // Verifies ClipHeightTo() uses the maximum height when the content is longer
 // thamn the maximum height value.
-TEST(ScrollViewTest, ClipHeightToTallContentHeight) {
-  ScrollView scroll_view;
-
+TEST_F(ScrollViewTest, ClipHeightToTallContentHeight) {
   // Use a scrollbar that is disabled by default, so the width of the content is
   // not affected.
-  scroll_view.SetVerticalScrollBar(new views::OverlayScrollBar(false));
+  scroll_view_.SetVerticalScrollBar(new views::OverlayScrollBar(false));
 
-  scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
+  scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   const int kTallContentHeight = 1000;
-  scroll_view.SetContents(
+  scroll_view_.SetContents(
       new views::StaticSizedView(gfx::Size(kWidth, kTallContentHeight)));
 
-  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.GetPreferredSize());
+  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.GetPreferredSize());
 
-  scroll_view.SizeToPreferredSize();
-  scroll_view.Layout();
+  scroll_view_.SizeToPreferredSize();
+  scroll_view_.Layout();
 
   EXPECT_EQ(gfx::Size(kWidth, kTallContentHeight),
-            scroll_view.contents()->size());
-  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.size());
+            scroll_view_.contents()->size());
+  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.size());
 }
 
 // Verifies that when ClipHeightTo() produces a scrollbar, it reduces the width
 // of the inner content of the ScrollView.
-TEST(ScrollViewTest, ClipHeightToScrollbarUsesWidth) {
-  ScrollView scroll_view;
-
-  scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
+TEST_F(ScrollViewTest, ClipHeightToScrollbarUsesWidth) {
+  scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   // Create a view that will be much taller than it is wide.
-  scroll_view.SetContents(new views::ProportionallySizedView(1000));
+  scroll_view_.SetContents(new views::ProportionallySizedView(1000));
 
   // Without any width, it will default to 0,0 but be overridden by min height.
-  scroll_view.SizeToPreferredSize();
-  EXPECT_EQ(gfx::Size(0, kMinHeight), scroll_view.GetPreferredSize());
+  scroll_view_.SizeToPreferredSize();
+  EXPECT_EQ(gfx::Size(0, kMinHeight), scroll_view_.GetPreferredSize());
 
-  gfx::Size new_size(kWidth, scroll_view.GetHeightForWidth(kWidth));
-  scroll_view.SetSize(new_size);
-  scroll_view.Layout();
+  gfx::Size new_size(kWidth, scroll_view_.GetHeightForWidth(kWidth));
+  scroll_view_.SetSize(new_size);
+  scroll_view_.Layout();
 
-  int scroll_bar_width = scroll_view.GetScrollBarWidth();
+  int scroll_bar_width = scroll_view_.GetScrollBarWidth();
   int expected_width = kWidth - scroll_bar_width;
-  EXPECT_EQ(scroll_view.contents()->size().width(), expected_width);
-  EXPECT_EQ(scroll_view.contents()->size().height(), 1000 * expected_width);
-  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.size());
+  EXPECT_EQ(scroll_view_.contents()->size().width(), expected_width);
+  EXPECT_EQ(scroll_view_.contents()->size().height(), 1000 * expected_width);
+  EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.size());
 }
 
-TEST(ScrollViewTest, CornerViewVisibility) {
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  View* corner_view = ScrollViewTestApi(&scroll_view).corner_view();
+TEST_F(ScrollViewTest, CornerViewVisibility) {
+  View* contents = InstallContents();
+  View* corner_view = ScrollViewTestApi(&scroll_view_).corner_view();
 
   // Corner view should be visible when both scrollbars are visible.
   contents->SetBounds(0, 0, 200, 200);
-  scroll_view.Layout();
-  EXPECT_EQ(&scroll_view, corner_view->parent());
+  scroll_view_.Layout();
+  EXPECT_EQ(&scroll_view_, corner_view->parent());
   EXPECT_TRUE(corner_view->visible());
 
   // Corner view should be aligned to the scrollbars.
-  EXPECT_EQ(scroll_view.vertical_scroll_bar()->x(), corner_view->x());
-  EXPECT_EQ(scroll_view.horizontal_scroll_bar()->y(), corner_view->y());
-  EXPECT_EQ(scroll_view.GetScrollBarWidth(), corner_view->width());
-  EXPECT_EQ(scroll_view.GetScrollBarHeight(), corner_view->height());
+  EXPECT_EQ(scroll_view_.vertical_scroll_bar()->x(), corner_view->x());
+  EXPECT_EQ(scroll_view_.horizontal_scroll_bar()->y(), corner_view->y());
+  EXPECT_EQ(scroll_view_.GetScrollBarWidth(), corner_view->width());
+  EXPECT_EQ(scroll_view_.GetScrollBarHeight(), corner_view->height());
 
   // Corner view should be removed when only the vertical scrollbar is visible.
   contents->SetBounds(0, 0, 50, 200);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_FALSE(corner_view->parent());
 
   // ... or when only the horizontal scrollbar is visible.
   contents->SetBounds(0, 0, 200, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_FALSE(corner_view->parent());
 
   // ... or when no scrollbar is visible.
   contents->SetBounds(0, 0, 50, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_FALSE(corner_view->parent());
 
   // Corner view should reappear when both scrollbars reappear.
   contents->SetBounds(0, 0, 200, 200);
-  scroll_view.Layout();
-  EXPECT_EQ(&scroll_view, corner_view->parent());
+  scroll_view_.Layout();
+  EXPECT_EQ(&scroll_view_, corner_view->parent());
   EXPECT_TRUE(corner_view->visible());
 }
 
 #if defined(OS_MACOSX)
 // Tests the overlay scrollbars on Mac. Ensure that they show up properly and
 // do not overlap each other.
-TEST(ScrollViewTest, CocoaOverlayScrollBars) {
-  std::unique_ptr<ui::test::ScopedPreferredScrollerStyle>
-      scroller_style_override;
-  scroller_style_override.reset(
-      new ui::test::ScopedPreferredScrollerStyle(true));
-  ScrollView scroll_view;
-  View* contents = new View;
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
+TEST_F(ScrollViewTest, CocoaOverlayScrollBars) {
+  SetOverlayScrollersEnabled(true);
+  View* contents = InstallContents();
 
   // Size the contents such that vertical scrollbar is needed.
   // Since it is overlaid, the ViewPort size should match the ScrollView.
   contents->SetBounds(0, 0, 50, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view.GetScrollBarWidth());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, true);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, false);
+  EXPECT_EQ(0, scroll_view_.GetScrollBarWidth());
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, false);
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view.GetScrollBarHeight());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, false);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, true);
+  EXPECT_EQ(0, scroll_view_.GetScrollBarHeight());
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, false);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Both horizontal and vertical scrollbars.
   contents->SetBounds(0, 0, 300, 400);
-  scroll_view.Layout();
+  scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view.GetScrollBarWidth());
-  EXPECT_EQ(0, scroll_view.GetScrollBarHeight());
-  CheckScrollbarVisibility(scroll_view, VERTICAL, true);
-  CheckScrollbarVisibility(scroll_view, HORIZONTAL, true);
+  EXPECT_EQ(0, scroll_view_.GetScrollBarWidth());
+  EXPECT_EQ(0, scroll_view_.GetScrollBarHeight());
+  CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
+  CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Make sure the horizontal and vertical scrollbars don't overlap each other.
-  gfx::Rect vert_bounds = scroll_view.vertical_scroll_bar()->bounds();
-  gfx::Rect horiz_bounds = scroll_view.horizontal_scroll_bar()->bounds();
+  gfx::Rect vert_bounds = scroll_view_.vertical_scroll_bar()->bounds();
+  gfx::Rect horiz_bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(vert_bounds.x(), horiz_bounds.right());
   EXPECT_EQ(horiz_bounds.y(), vert_bounds.bottom());
 
   // Switch to the non-overlay style and check that the ViewPort is now sized
   // to be smaller, and ScrollbarWidth and ScrollbarHeight are non-zero.
-  scroller_style_override.reset(
-      new ui::test::ScopedPreferredScrollerStyle(false));
-  EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view.GetScrollBarHeight(),
+  SetOverlayScrollersEnabled(false);
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+            contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
             contents->parent()->height());
-  EXPECT_NE(0, scroll_view.GetScrollBarWidth());
-  EXPECT_NE(0, scroll_view.GetScrollBarHeight());
+  EXPECT_NE(0, scroll_view_.GetScrollBarWidth());
+  EXPECT_NE(0, scroll_view_.GetScrollBarHeight());
 }
 #endif
 
 // Test that increasing the size of the viewport "below" scrolled content causes
 // the content to scroll up so that it still fills the viewport.
-TEST(ScrollViewTest, ConstrainScrollToBounds) {
-  ScrollView scroll_view;
-  ScrollViewTestApi test_api(&scroll_view);
+TEST_F(ScrollViewTest, ConstrainScrollToBounds) {
+  ScrollViewTestApi test_api(&scroll_view_);
 
-  View* contents = new View;
+  View* contents = InstallContents();
   contents->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
-  scroll_view.SetContents(contents);
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
-  scroll_view.Layout();
+  scroll_view_.Layout();
 
   EXPECT_EQ(gfx::ScrollOffset(), test_api.CurrentOffset());
 
   // Scroll as far as it goes and query location to discount scroll bars.
   contents->ScrollRectToVisible(gfx::Rect(300, 300, 1, 1));
   const gfx::ScrollOffset fully_scrolled = test_api.CurrentOffset();
   EXPECT_NE(gfx::ScrollOffset(), fully_scrolled);
 
   // Making the viewport 55 pixels taller should scroll up the same amount.
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 155));
-  scroll_view.Layout();
+  scroll_view_.SetBoundsRect(gfx::Rect(0, 0, 100, 155));
+  scroll_view_.Layout();
   EXPECT_EQ(fully_scrolled.y() - 55, test_api.CurrentOffset().y());
   EXPECT_EQ(fully_scrolled.x(), test_api.CurrentOffset().x());
 
   // And 77 pixels wider should scroll left. Also make it short again: the y-
   // offset from the last change should remain.
-  scroll_view.SetBoundsRect(gfx::Rect(0, 0, 177, 100));
-  scroll_view.Layout();
+  scroll_view_.SetBoundsRect(gfx::Rect(0, 0, 177, 100));
+  scroll_view_.Layout();
   EXPECT_EQ(fully_scrolled.y() - 55, test_api.CurrentOffset().y());
   EXPECT_EQ(fully_scrolled.x() - 77, test_api.CurrentOffset().x());
 }
 
 // Test scrolling behavior when clicking on the scroll track.
 TEST_F(WidgetScrollViewTest, ScrollTrackScrolling) {
   // Set up with a vertical scroller.
-  ScrollView* scroll_view =
+  ScrollView* scroll_view_ =
       AddScrollViewWithContentSize(gfx::Size(10, kDefaultHeight * 5));
-  ScrollViewTestApi test_api(scroll_view);
+  ScrollViewTestApi test_api(scroll_view_);
   BaseScrollBar* scroll_bar = test_api.GetBaseScrollBar(VERTICAL);
   View* thumb = test_api.GetScrollBarThumb(VERTICAL);
 
   // Click in the middle of the track, ensuring it's below the thumb.
   const gfx::Point location = scroll_bar->bounds().CenterPoint();
   EXPECT_GT(location.y(), thumb->bounds().bottom());
   ui::MouseEvent press(TestLeftMouseAt(location, ui::ET_MOUSE_PRESSED));
   ui::MouseEvent release(TestLeftMouseAt(location, ui::ET_MOUSE_RELEASED));
 
   const base::Timer& timer = test_api.GetScrollBarTimer(VERTICAL);
   EXPECT_FALSE(timer.IsRunning());
 
-  EXPECT_EQ(0, scroll_view->GetVisibleRect().y());
+  EXPECT_EQ(0, scroll_view_->GetVisibleRect().y());
   scroll_bar->OnMouseEvent(&press);
 
   // Clicking the scroll track should scroll one "page".
-  EXPECT_EQ(kDefaultHeight, scroll_view->GetVisibleRect().y());
+  EXPECT_EQ(kDefaultHeight, scroll_view_->GetVisibleRect().y());
 
   // While the mouse is pressed, timer should trigger more scroll events.
   EXPECT_TRUE(timer.IsRunning());
 
   // Upon release timer should stop (and scroll position should remain).
   scroll_bar->OnMouseEvent(&release);
   EXPECT_FALSE(timer.IsRunning());
-  EXPECT_EQ(kDefaultHeight, scroll_view->GetVisibleRect().y());
+  EXPECT_EQ(kDefaultHeight, scroll_view_->GetVisibleRect().y());
 }
 
 // Test that LocatedEvents are transformed correctly when scrolling.
 TEST_F(WidgetScrollViewTest, EventLocation) {
   // Set up with both scrollers.
   CustomView* contents = new CustomView;
   contents->SetPreferredSize(gfx::Size(kDefaultHeight * 5, kDefaultHeight * 5));
   AddScrollViewWithContents(contents);
 
   const gfx::Point location_in_widget(10, 10);
@@ skipping 74 matching lines @@
   // Scroll via ScrollView API. Should be reflected on the impl side.
   offset.set_y(kDefaultHeight * 4);
   scroll_view->contents()->ScrollRectToVisible(offset);
   EXPECT_EQ(gfx::ScrollOffset(0, offset.y()), test_api.CurrentOffset());
 
   EXPECT_TRUE(compositor->GetScrollOffsetForLayer(layer_id, &impl_offset));
   EXPECT_EQ(gfx::ScrollOffset(0, offset.y()), impl_offset);
 }
 
 }  // namespace views