[ABANDONED] Simplify ash shelf dimmer.

ash/shelf/shelf_layout_manager_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 "ash/shelf/shelf_layout_manager.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/accelerators/accelerator_table.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray.h"
 #include "ash/common/system/tray/system_tray_item.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_manager.h"
-#include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/shelf_test_api.h"
+#include "ash/test/status_area_widget_test_helper.h"
 #include "ash/test/test_system_tray_item.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 129 matching lines @@
     } else if (SHELF_ALIGNMENT_RIGHT ==
                GetShelfLayoutManager()->GetAlignment()) {
       EXPECT_EQ(auto_hidden_shelf_widget_bounds_.right(), shelf_bounds.right());
       EXPECT_EQ(shelf_widget_bounds_.right(), shelf_bounds.right());
     } else if (SHELF_ALIGNMENT_LEFT ==
                GetShelfLayoutManager()->GetAlignment()) {
       EXPECT_EQ(auto_hidden_shelf_widget_bounds_.x(), shelf_bounds.x());
       EXPECT_EQ(shelf_widget_bounds_.x(), shelf_bounds.x());
     }
 
-    // if the shelf is being dimmed test dimmer bounds as well.
-    if (GetShelfWidget()->GetDimsShelf())
-      EXPECT_EQ(GetShelfWidget()->GetWindowBoundsInScreen(),
-                GetShelfWidget()->GetDimmerBoundsForTest());
-
     // Auto hidden shelf has a visible height of 0 in MD (where this inequality
     // does not apply); whereas auto hidden shelf has a visible height of 3 in
     // non-MD.
     if (!ash::MaterialDesignController::IsShelfMaterial() ||
         GetShelf()->GetAutoHideState() != ash::SHELF_AUTO_HIDE_HIDDEN) {
       EXPECT_GE(shelf_bounds.height(),
                 auto_hidden_shelf_widget_bounds_.height());
     }
 
     float scroll_delta =
@@ skipping 99 matching lines @@
   }
 
   views::Widget* CreateTestWidgetWithParams(
       const views::Widget::InitParams& params) {
     views::Widget* out = new views::Widget;
     out->Init(params);
     out->Show();
     return out;
   }
 
-  // Create a simple widget attached to the current context (will
-  // delete on TearDown).
+  // Create a simple widget in the current context (will delete on TearDown).
   views::Widget* CreateTestWidget() {
     views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     params.context = CurrentContext();
     return CreateTestWidgetWithParams(params);
   }
 
   void RunGestureDragTests(gfx::Vector2d);
 
   // Turn on the lock screen.
@@ skipping 10 matching lines @@
     Shell::GetInstance()->OnLockStateChanged(false);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManagerTest);
 };
 
 void ShelfLayoutManagerTest::RunGestureDragTests(gfx::Vector2d delta) {
   Shelf* shelf = GetShelf();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  widget->Init(params);
-  widget->Show();
+
+  views::Widget* widget = CreateTestWidget();
   widget->Maximize();
 
   // The time delta should be large enough to prevent accidental fling creation.
   const base::TimeDelta kTimeDelta = base::TimeDelta::FromMilliseconds(100);
 
   aura::Window* window = widget->GetNativeWindow();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   layout_manager->LayoutShelf();
 
   gfx::Rect shelf_shown = GetShelfWidget()->GetWindowBoundsInScreen();
   gfx::Rect bounds_shelf = window->bounds();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   gfx::Rect bounds_noshelf = window->bounds();
   gfx::Rect shelf_hidden = GetShelfWidget()->GetWindowBoundsInScreen();
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   layout_manager->LayoutShelf();
 
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator(GetEventGenerator());
   const int kNumScrollSteps = 4;
   ShelfDragCallback handler(shelf_hidden, shelf_shown);
 
   // Swipe up on the shelf. This should not change any state.
   gfx::Point start = GetShelfWidget()->GetWindowBoundsInScreen().CenterPoint();
   gfx::Point end = start + delta;
 
   // Swipe down on the shelf to hide it.
   generator.GestureScrollSequenceWithCallback(
       start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
   EXPECT_NE(bounds_shelf.ToString(), window->bounds().ToString());
   EXPECT_NE(shelf_shown.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up to show the shelf.
   generator.GestureScrollSequenceWithCallback(
       end, start, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
-            GetShelfWidget()->GetWindowBoundsInScreen());
   EXPECT_EQ(shelf_shown.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up again. The shelf should hide.
   end = start - delta;
   generator.GestureScrollSequenceWithCallback(
       start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
@@ skipping 25 matching lines @@
 
   // Swipe down again to hide.
   end = start + delta;
   generator.GestureScrollSequenceWithCallback(
       start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(shelf_hidden.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up in extended hit region to show it.
   gfx::Point extended_start = start;
   if (GetShelfLayoutManager()->IsHorizontalAlignment())
     extended_start.set_y(GetShelfWidget()->GetWindowBoundsInScreen().y() - 1);
   else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
     extended_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().right() +
                          1);
   else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
     extended_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
   end = extended_start - delta;
   generator.GestureScrollSequenceWithCallback(
       extended_start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
-            GetShelfWidget()->GetWindowBoundsInScreen());
   EXPECT_EQ(shelf_shown.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe down again to hide.
   end = start + delta;
   generator.GestureScrollSequenceWithCallback(
       start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(shelf_hidden.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up outside the hit area. This should not change anything.
   gfx::Point outside_start =
       gfx::Point((GetShelfWidget()->GetWindowBoundsInScreen().x() +
                   GetShelfWidget()->GetWindowBoundsInScreen().right()) /
                      2,
                  GetShelfWidget()->GetWindowBoundsInScreen().y() - 50);
@@ skipping 14 matching lines @@
   else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
     below_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
   else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
     below_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().right() + 1);
   end = below_start - delta;
   generator.GestureScrollSequence(below_start, end, kTimeDelta,
                                   kNumScrollSteps);
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
-            GetShelfWidget()->GetWindowBoundsInScreen());
   EXPECT_EQ(shelf_shown.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe down again to hide.
   end = start + delta;
   generator.GestureScrollSequenceWithCallback(
       start, end, kTimeDelta, kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
-  EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(shelf_hidden.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Put |widget| into fullscreen. Set the shelf to be auto hidden when |widget|
   // is fullscreen. (eg browser immersive fullscreen).
   widget->SetFullscreen(true);
   wm::GetWindowState(window)->set_hide_shelf_when_fullscreen(false);
   layout_manager->UpdateVisibilityState();
 
@@ skipping 82 matching lines @@
   ShelfWidget* shelf_widget = GetShelfWidget();
   ShelfLayoutManager* manager = shelf_widget->shelf_layout_manager();
   // Force an initial layout.
   manager->LayoutShelf();
   EXPECT_EQ(SHELF_VISIBLE, manager->visibility_state());
 
   gfx::Rect status_bounds(
       shelf_widget->status_area_widget()->GetWindowBoundsInScreen());
   gfx::Rect shelf_bounds(shelf_widget->GetWindowBoundsInScreen());
   int shelf_height = manager->GetIdealBounds().height();
-  display::Screen* screen = display::Screen::GetScreen();
-  display::Display display =
-      screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   ASSERT_NE(-1, display.id());
   // Bottom inset should be the max of widget heights.
   EXPECT_EQ(shelf_height, display.GetWorkAreaInsets().bottom());
 
   // Hide the shelf.
   SetState(manager, SHELF_HIDDEN);
   // Run the animation to completion.
   StepWidgetLayerAnimatorToEnd(shelf_widget);
   StepWidgetLayerAnimatorToEnd(shelf_widget->status_area_widget());
   EXPECT_EQ(SHELF_HIDDEN, manager->visibility_state());
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
 
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
 
   // Make sure the bounds of the two widgets changed.
   EXPECT_GE(shelf_widget->GetNativeView()->bounds().y(),
-            screen->GetPrimaryDisplay().bounds().bottom());
+            display.bounds().bottom());
   EXPECT_GE(shelf_widget->status_area_widget()->GetNativeView()->bounds().y(),
-            screen->GetPrimaryDisplay().bounds().bottom());
+            display.bounds().bottom());
 
   // And show it again.
   SetState(manager, SHELF_VISIBLE);
   // Run the animation to completion.
   StepWidgetLayerAnimatorToEnd(shelf_widget);
   StepWidgetLayerAnimatorToEnd(shelf_widget->status_area_widget());
   EXPECT_EQ(SHELF_VISIBLE, manager->visibility_state());
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   EXPECT_EQ(shelf_height, display.GetWorkAreaInsets().bottom());
 
   // Make sure the bounds of the two widgets changed.
   shelf_bounds = shelf_widget->GetNativeView()->bounds();
-  EXPECT_LT(shelf_bounds.y(), screen->GetPrimaryDisplay().bounds().bottom());
+  EXPECT_LT(shelf_bounds.y(), display.bounds().bottom());
   status_bounds = shelf_widget->status_area_widget()->GetNativeView()->bounds();
-  EXPECT_LT(status_bounds.y(), screen->GetPrimaryDisplay().bounds().bottom());
+  EXPECT_LT(status_bounds.y(), display.bounds().bottom());
 }
 
 // Makes sure LayoutShelf invoked while animating cleans things up.
 TEST_F(ShelfLayoutManagerTest, LayoutShelfWhileAnimating) {
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   // Force an initial layout.
   layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   // Hide the shelf.
   SetState(layout_manager, SHELF_HIDDEN);
   layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState());
-  display::Display display =
-      display::Screen::GetScreen()->GetDisplayNearestWindow(
-          Shell::GetPrimaryRootWindow());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
 
   // Make sure the bounds of the two widgets changed.
   ShelfWidget* shelf_widget = GetShelfWidget();
-  EXPECT_GE(
-      shelf_widget->GetNativeView()->bounds().y(),
-      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().bottom());
-  EXPECT_GE(
-      shelf_widget->status_area_widget()->GetNativeView()->bounds().y(),
-      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().bottom());
+  EXPECT_GE(shelf_widget->GetNativeView()->bounds().y(),
+            display.bounds().bottom());
+  EXPECT_GE(shelf_widget->status_area_widget()->GetNativeView()->bounds().y(),
+            display.bounds().bottom());
 }
 
 // Test that switching to a different visibility state does not restart the
 // shelf show / hide animation if it is already running. (crbug.com/250918)
 TEST_F(ShelfLayoutManagerTest, SetStateWhileAnimating) {
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   SetState(layout_manager, SHELF_VISIBLE);
   ShelfWidget* shelf_widget = GetShelfWidget();
   gfx::Rect initial_shelf_bounds = shelf_widget->GetWindowBoundsInScreen();
   gfx::Rect initial_status_bounds =
@@ skipping 22 matching lines @@
   Shelf* shelf = GetShelf();
   ASSERT_TRUE(shelf);
   ShelfWidget* shelf_widget = GetShelfWidget();
   ASSERT_TRUE(shelf_widget);
   ASSERT_TRUE(shelf_widget->status_area_widget());
   shelf_widget->status_area_widget()->SetBounds(gfx::Rect(0, 0, 200, 200));
   EXPECT_EQ(200, shelf_widget->GetContentsView()->width() -
                      test::ShelfTestAPI(shelf).shelf_view()->width());
 }
 
-#if defined(OS_WIN)
-// RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
-#define MAYBE_AutoHide DISABLED_AutoHide
-#else
-#define MAYBE_AutoHide AutoHide
-#endif
-
 // Various assertions around auto-hide.
-TEST_F(ShelfLayoutManagerTest, MAYBE_AutoHide) {
-  aura::Window* root = Shell::GetPrimaryRootWindow();
-  ui::test::EventGenerator generator(root, root);
-  generator.MoveMouseTo(0, 0);
+TEST_F(ShelfLayoutManagerTest, AutoHide) {
+  ui::test::EventGenerator& generator(GetEventGenerator());
 
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
+  views::Widget* widget = CreateTestWidget();
   widget->Maximize();
-  widget->Show();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   // LayoutShelf() forces the animation to completion, at which point the
   // shelf should go off the screen.
   layout_manager->LayoutShelf();
   int shelf_insets = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
 
+  aura::Window* root = Shell::GetPrimaryRootWindow();
   EXPECT_EQ(root->bounds().bottom() - kShelfAutoHideSize,
             GetShelfWidget()->GetWindowBoundsInScreen().y());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(root->bounds().bottom() - shelf_insets,
-            display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(root)
-                .work_area()
-                .bottom());
+            display.work_area().bottom());
 
   // Move the mouse to the bottom of the screen.
   generator.MoveMouseTo(0, root->bounds().bottom() - 1);
 
   // Shelf should be shown again (but it shouldn't have changed the work area).
   SetState(layout_manager, SHELF_AUTO_HIDE);
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
   layout_manager->LayoutShelf();
   EXPECT_EQ(root->bounds().bottom() - layout_manager->GetIdealBounds().height(),
             GetShelfWidget()->GetWindowBoundsInScreen().y());
   EXPECT_EQ(root->bounds().bottom() - shelf_insets,
-            display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(root)
-                .work_area()
-                .bottom());
+            display.work_area().bottom());
 
   // Move mouse back up.
   generator.MoveMouseTo(0, 0);
   SetState(layout_manager, SHELF_AUTO_HIDE);
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   layout_manager->LayoutShelf();
   EXPECT_EQ(root->bounds().bottom() - kShelfAutoHideSize,
             GetShelfWidget()->GetWindowBoundsInScreen().y());
 
   // Drag mouse to bottom of screen.
@@ skipping 101 matching lines @@
 
   // Moving to the left edge of the secondary display without first crossing
   // the primary display's right aligned shelf first should not show the shelf.
   generator.MoveMouseTo(right_edge + 2, y);
   UpdateAutoHideStateNow();
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 }
 
 // Assertions around the lock screen showing.
 TEST_F(ShelfLayoutManagerTest, VisibleWhenLockScreenShowing) {
-  if (!SupportsHostWindowResize())
-    return;
-
-  // Since ShelfLayoutManager queries for mouse location, move the mouse so
-  // it isn't over the shelf.
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
-  generator.MoveMouseTo(0, 0);
-
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
+  views::Widget* widget = CreateTestWidget();
   widget->Maximize();
-  widget->Show();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   aura::Window* root = Shell::GetPrimaryRootWindow();
   // LayoutShelf() forces the animation to completion, at which point the
   // shelf should go off the screen.
   layout_manager->LayoutShelf();
   EXPECT_EQ(root->bounds().bottom() - kShelfAutoHideSize,
             GetShelfWidget()->GetWindowBoundsInScreen().y());
 
-  aura::Window* lock_container = Shell::GetContainer(
-      Shell::GetPrimaryRootWindow(), kShellWindowId_LockScreenContainer);
-
-  views::Widget* lock_widget = new views::Widget;
-  views::Widget::InitParams lock_params(views::Widget::InitParams::TYPE_WINDOW);
-  lock_params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  lock_params.parent = lock_container;
-  // Widget is now owned by the parent window.
-  lock_widget->Init(lock_params);
+  std::unique_ptr<views::Widget> lock_widget(AshTestBase::CreateTestWidget(
+      nullptr, kShellWindowId_LockScreenContainer, gfx::Rect(200, 200)));
   lock_widget->Maximize();
-  lock_widget->Show();
 
   // Lock the screen.
   LockScreen();
   // Showing a widget in the lock screen should force the shelf to be visibile.
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   UnlockScreen();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 }
 
 // Assertions around SetAutoHideBehavior.
 TEST_F(ShelfLayoutManagerTest, SetAutoHideBehavior) {
-  // Since ShelfLayoutManager queries for mouse location, move the mouse so
-  // it isn't over the shelf.
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
-  generator.MoveMouseTo(0, 0);
-
   Shelf* shelf = GetShelf();
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
-  widget->Show();
-  aura::Window* window = widget->GetNativeWindow();
+  views::Widget* widget = CreateTestWidget();
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   widget->Maximize();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
-  EXPECT_EQ(display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(window)
-                .work_area()
-                .bottom(),
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  EXPECT_EQ(display.work_area().bottom(),
             widget->GetWorkAreaBoundsInScreen().bottom());
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
-  EXPECT_EQ(display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(window)
-                .work_area()
-                .bottom(),
+  EXPECT_EQ(display.work_area().bottom(),
             widget->GetWorkAreaBoundsInScreen().bottom());
 
   ui::ScopedAnimationDurationScaleMode animation_duration(
       ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   ShelfWidget* shelf_widget = GetShelfWidget();
   EXPECT_TRUE(shelf_widget->status_area_widget()->IsVisible());
   StepWidgetLayerAnimatorToEnd(shelf_widget);
   StepWidgetLayerAnimatorToEnd(shelf_widget->status_area_widget());
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
-  EXPECT_EQ(display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(window)
-                .work_area()
-                .bottom(),
+  EXPECT_EQ(display.work_area().bottom(),
             widget->GetWorkAreaBoundsInScreen().bottom());
 }
 
 // Basic assertions around the dimming of the shelf.
 TEST_F(ShelfLayoutManagerTest, DimmingBehavior) {
-  // Since ShelfLayoutManager queries for mouse location, move the mouse so
-  // it isn't over the shelf.
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
-  generator.MoveMouseTo(0, 0);
+  ui::test::EventGenerator& generator(GetEventGenerator());
+  views::Widget* widget = CreateTestWidget();
 
   ShelfWidget* shelf_widget = GetShelfWidget();
-  shelf_widget->DisableDimmingAnimationsForTest();
-
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
-  widget->Show();
-  aura::Window* window = widget->GetNativeWindow();
-  gfx::Rect display_bounds(
-      display::Screen::GetScreen()->GetDisplayNearestWindow(window).bounds());
-
-  gfx::Point off_shelf = display_bounds.CenterPoint();
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  gfx::Point off_shelf = display.bounds().CenterPoint();
   gfx::Point on_shelf = shelf_widget->GetWindowBoundsInScreen().CenterPoint();
 
-  // Test there is no dimming object active at this point.
-  generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
-  EXPECT_EQ(-1, shelf_widget->GetDimmingAlphaForTest());
-  generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
-  EXPECT_EQ(-1, shelf_widget->GetDimmingAlphaForTest());
+  // Test that the shelf is not dimmed at this point.
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(off_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 
-  // After maximization, the shelf should be visible and the dimmer created.
+  // Maximizing the window should dim the shelf.
   widget->Maximize();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
 
-  on_shelf = shelf_widget->GetWindowBoundsInScreen().CenterPoint();
-  EXPECT_LT(0, shelf_widget->GetDimmingAlphaForTest());
+  // Mouse move events outside the shelf should keep the shelf dimmed.
+  generator.MoveMouseTo(off_shelf.x() + 10, off_shelf.y() + 10);
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
 
-  // Moving the mouse off the shelf should dim the bar.
-  generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
-  EXPECT_LT(0, shelf_widget->GetDimmingAlphaForTest());
+  // Mouse move events inside the shelf should undim the shelf.
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 
-  // Adding touch events outside the shelf should still keep the shelf in
-  // dimmed state.
+  // Mouse drags starting outside the shelf are not captured.
+  generator.MoveMouseTo(off_shelf);
+  generator.PressLeftButton();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(off_shelf);
+  generator.ReleaseLeftButton();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
+
+  // Mouse drags starting inside the shelf are captured.
+  generator.MoveMouseTo(on_shelf);
+  generator.PressLeftButton();
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(off_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(on_shelf);
+  generator.ReleaseLeftButton();
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+
+  // Touch drags outside the shelf should keep the shelf dimmed.
+  generator.MoveTouch(off_shelf);
   generator.PressTouch();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
+  generator.MoveTouch(gfx::Point(off_shelf.x() + 10, off_shelf.y() + 10));
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
   generator.MoveTouch(off_shelf);
-  EXPECT_LT(0, shelf_widget->GetDimmingAlphaForTest());
-  // Move the touch into the shelf area should undim.
+  generator.ReleaseTouch();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
+
+  // Touch drags inside the shelf should undim the shelf until release.
   generator.MoveTouch(on_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
-  generator.ReleaseTouch();
-  // And a release dims again.
-  EXPECT_LT(0, shelf_widget->GetDimmingAlphaForTest());
-
-  // Moving the mouse on the shelf should undim the bar.
-  generator.MoveMouseTo(on_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
-
-  // No matter what the touch events do, the shelf should stay undimmed.
   generator.PressTouch();
-  generator.MoveTouch(off_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
-  generator.MoveTouch(on_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
-  generator.MoveTouch(off_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+  generator.MoveTouch(gfx::Point(on_shelf.x() + 1, on_shelf.y() + 1));
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   generator.MoveTouch(on_shelf);
   generator.ReleaseTouch();
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
 
-  // After restore, the dimming object should be deleted again.
+  // After restore, the shelf should be undimmed.
+  generator.MoveMouseTo(off_shelf);
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
   widget->Restore();
-  EXPECT_EQ(-1, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 }
 
 // Test that dimming works correctly with multiple displays.
 TEST_F(ShelfLayoutManagerTest, DimmingBehaviorDualDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Create two displays.
-  Shell* shell = Shell::GetInstance();
-  UpdateDisplay("0+0-200x200,+200+0-100x100");
-  EXPECT_EQ(2U, shell->display_manager()->GetNumDisplays());
-
-  WindowTreeHostManager* window_tree_host_manager =
-      shell->window_tree_host_manager();
-  aura::Window::Windows root_windows =
-      window_tree_host_manager->GetAllRootWindows();
+  UpdateDisplay("0+0-300x300,+600+0-300x300");
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows.size(), 2U);
 
   std::vector<ShelfWidget*> shelf_widgets;
   for (auto* root_window : root_windows) {
     ShelfLayoutManager* shelf =
         GetRootWindowController(root_window)->GetShelfLayoutManager();
     shelf_widgets.push_back(shelf->shelf_widget());
-
-    // For disabling the dimming animation to work, the animation must be
-    // disabled prior to creating the dimmer.
-    shelf_widgets.back()->DisableDimmingAnimationsForTest();
-
-    // Create a maximized window to create the dimmer.
-    views::Widget* widget = new views::Widget;
-    views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-    params.context = root_window;
-    params.bounds = root_window->GetBoundsInScreen();
-    params.show_state = ui::SHOW_STATE_MAXIMIZED;
-    widget->Init(params);
-    widget->Show();
+    // Force the shelf to enable dimming with a maximized window background.
+    shelf->shelf_widget()->SetPaintsBackground(SHELF_BACKGROUND_MAXIMIZED,
+                                               BACKGROUND_CHANGE_IMMEDIATE);
   }
 
   ui::test::EventGenerator& generator(GetEventGenerator());
-
   generator.MoveMouseTo(root_windows[0]->GetBoundsInScreen().CenterPoint());
-  EXPECT_LT(0, shelf_widgets[0]->GetDimmingAlphaForTest());
-  EXPECT_LT(0, shelf_widgets[1]->GetDimmingAlphaForTest());
+  EXPECT_TRUE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_TRUE(shelf_widgets[1]->GetDimsShelf());
 
   generator.MoveMouseTo(
       shelf_widgets[0]->GetWindowBoundsInScreen().CenterPoint());
-  EXPECT_EQ(0, shelf_widgets[0]->GetDimmingAlphaForTest());
-  EXPECT_LT(0, shelf_widgets[1]->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_TRUE(shelf_widgets[1]->GetDimsShelf());
+
+  generator.MoveMouseTo(root_windows[0]->GetBoundsInScreen().CenterPoint());
+  EXPECT_TRUE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_TRUE(shelf_widgets[1]->GetDimsShelf());
+
+  generator.MoveMouseTo(root_windows[1]->GetBoundsInScreen().CenterPoint());
+  EXPECT_TRUE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_TRUE(shelf_widgets[1]->GetDimsShelf());
 
   generator.MoveMouseTo(
       shelf_widgets[1]->GetWindowBoundsInScreen().CenterPoint());
-  EXPECT_LT(0, shelf_widgets[0]->GetDimmingAlphaForTest());
-  EXPECT_EQ(0, shelf_widgets[1]->GetDimmingAlphaForTest());
+  EXPECT_TRUE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_FALSE(shelf_widgets[1]->GetDimsShelf());
 
   generator.MoveMouseTo(root_windows[1]->GetBoundsInScreen().CenterPoint());
-  EXPECT_LT(0, shelf_widgets[0]->GetDimmingAlphaForTest());
-  EXPECT_LT(0, shelf_widgets[1]->GetDimmingAlphaForTest());
+  EXPECT_TRUE(shelf_widgets[0]->GetDimsShelf());
+  EXPECT_TRUE(shelf_widgets[1]->GetDimsShelf());
 }
 
 // Assertions around the dimming of the shelf in conjunction with menus.
 TEST_F(ShelfLayoutManagerTest, DimmingBehaviorWithMenus) {
-  // Since ShelfLayoutManager queries for mouse location, move the mouse so
-  // it isn't over the shelf.
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
-  generator.MoveMouseTo(0, 0);
+  ui::test::EventGenerator& generator(GetEventGenerator());
+
+  // Maximize a widget to make shelf dimming possible.
+  views::Widget* widget = CreateTestWidget();
+  widget->Maximize();
 
   ShelfWidget* shelf_widget = GetShelfWidget();
-  shelf_widget->DisableDimmingAnimationsForTest();
-
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
-  widget->Show();
-  aura::Window* window = widget->GetNativeWindow();
-  gfx::Rect display_bounds(
-      display::Screen::GetScreen()->GetDisplayNearestWindow(window).bounds());
-
-  // After maximization, the shelf should be visible and the dimmer created.
-  widget->Maximize();
-
-  gfx::Point off_shelf = display_bounds.CenterPoint();
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  gfx::Point off_shelf = display.bounds().CenterPoint();
   gfx::Point on_shelf = shelf_widget->GetWindowBoundsInScreen().CenterPoint();
 
   // Moving the mouse on the shelf should undim the bar.
-  generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 
   // Simulate a menu opening.
   shelf_widget->ForceUndimming(true);
 
   // Moving the mouse off the shelf should not dim the bar.
-  generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  generator.MoveMouseTo(off_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 
   // No matter what the touch events do, the shelf should stay undimmed.
   generator.PressTouch();
   generator.MoveTouch(off_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   generator.MoveTouch(on_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   generator.MoveTouch(off_shelf);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   generator.ReleaseTouch();
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 
   // "Closing the menu" should now turn off the menu since no event is inside
   // the shelf any longer.
   shelf_widget->ForceUndimming(false);
-  EXPECT_LT(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_TRUE(shelf_widget->GetDimsShelf());
 
   // Moving the mouse again on the shelf which should undim the bar again.
   // This time we check that the bar stays undimmed when the mouse remains on
   // the bar and the "menu gets closed".
-  generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   shelf_widget->ForceUndimming(true);
-  generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
-  generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  generator.MoveMouseTo(off_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
+  generator.MoveMouseTo(on_shelf);
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
   shelf_widget->ForceUndimming(true);
-  EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
+  EXPECT_FALSE(shelf_widget->GetDimsShelf());
 }
 
 // Verifies the shelf is visible when status/shelf is focused.
 TEST_F(ShelfLayoutManagerTest, VisibleWhenStatusOrShelfFocused) {
-  // Since ShelfLayoutManager queries for mouse location, move the mouse so
-  // it isn't over the shelf.
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
-  generator.MoveMouseTo(0, 0);
-
   Shelf* shelf = GetShelf();
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  // Widget is now owned by the parent window.
-  widget->Init(params);
-  widget->Show();
+  views::Widget* widget = CreateTestWidget();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   // Focus the shelf. Have to go through the focus cycler as normal focus
   // requests to it do nothing.
   GetShelfWidget()->GetFocusCycler()->RotateFocus(FocusCycler::FORWARD);
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
 
   widget->Activate();
@@ skipping 78 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
 
   // Create two displays.
   Shell* shell = Shell::GetInstance();
   DisplayManager* display_manager = shell->display_manager();
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   UpdateDisplay("0+0-200x200,+200+0-100x100");
   EXPECT_EQ(2U, display_manager->GetNumDisplays());
 
-  WindowTreeHostManager* window_tree_host_manager =
-      shell->window_tree_host_manager();
-  aura::Window::Windows root_windows =
-      window_tree_host_manager->GetAllRootWindows();
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows.size(), 2U);
 
   // Get the shelves in both displays and set them to be 'AutoHide'.
   Shelf* shelf_1 = GetRootWindowController(root_windows[0])->GetShelf();
   Shelf* shelf_2 = GetRootWindowController(root_windows[1])->GetShelf();
   EXPECT_NE(shelf_1, shelf_2);
   EXPECT_NE(shelf_1->shelf_widget()->GetNativeWindow()->GetRootWindow(),
             shelf_2->shelf_widget()->GetNativeWindow()->GetRootWindow());
   shelf_1->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   shelf_1->shelf_layout_manager()->LayoutShelf();
@@ skipping 107 matching lines @@
 TEST_F(ShelfLayoutManagerTest, ShelfWithSystemModalWindowDualDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Create two displays.
   Shell* shell = Shell::GetInstance();
   DisplayManager* display_manager = shell->display_manager();
   UpdateDisplay("200x200,100x100");
   EXPECT_EQ(2U, display_manager->GetNumDisplays());
 
-  WindowTreeHostManager* window_tree_host_manager =
-      shell->window_tree_host_manager();
-  aura::Window::Windows root_windows =
-      window_tree_host_manager->GetAllRootWindows();
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(2U, root_windows.size());
 
   // Get the shelves in both displays and set them to be 'AutoHide'.
   Shelf* shelf_1 = GetRootWindowController(root_windows[0])->GetShelf();
   Shelf* shelf_2 = GetRootWindowController(root_windows[1])->GetShelf();
   EXPECT_NE(shelf_1, shelf_2);
   EXPECT_NE(shelf_1->shelf_widget()->GetNativeWindow()->GetRootWindow(),
             shelf_2->shelf_widget()->GetNativeWindow()->GetRootWindow());
   shelf_1->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   shelf_1->shelf_layout_manager()->LayoutShelf();
@@ skipping 101 matching lines @@
 
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   wm::PinWindow(window1);
   EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState());
 
   WmWindowAura::Get(window1)->GetWindowState()->Restore();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 }
 
-#if defined(OS_WIN)
-// RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
-#define MAYBE_SetAlignment DISABLED_SetAlignment
-#else
-#define MAYBE_SetAlignment SetAlignment
-#endif
-
 // Tests SHELF_ALIGNMENT_(LEFT, RIGHT).
-TEST_F(ShelfLayoutManagerTest, MAYBE_SetAlignment) {
+TEST_F(ShelfLayoutManagerTest, SetAlignment) {
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   // Force an initial layout.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
   gfx::Rect shelf_bounds(GetShelfWidget()->GetWindowBoundsInScreen());
-  const display::Screen* screen = display::Screen::GetScreen();
-  display::Display display =
-      screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   ASSERT_NE(-1, display.id());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().left());
   EXPECT_GE(shelf_bounds.width(),
             GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(SHELF_ALIGNMENT_LEFT, GetSystemTray()->shelf_alignment());
   StatusAreaWidget* status_area_widget = GetShelfWidget()->status_area_widget();
   gfx::Rect status_bounds(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_GE(status_bounds.width(),
             status_area_widget->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().left());
   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
   EXPECT_EQ(0, display.GetWorkAreaInsets().right());
   EXPECT_EQ(display.bounds().x(), shelf_bounds.x());
   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
   EXPECT_EQ(display.bounds().height(), shelf_bounds.height());
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   EXPECT_EQ(GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE),
             display.GetWorkAreaInsets().left());
   EXPECT_EQ(GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE),
             display.work_area().x());
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   ASSERT_NE(-1, display.id());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().right());
   EXPECT_GE(shelf_bounds.width(),
             GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(SHELF_ALIGNMENT_RIGHT, GetSystemTray()->shelf_alignment());
   status_bounds = gfx::Rect(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_GE(status_bounds.width(),
             status_area_widget->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().right());
   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
   EXPECT_EQ(0, display.GetWorkAreaInsets().left());
   EXPECT_EQ(display.work_area().right(), shelf_bounds.x());
   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
   EXPECT_EQ(display.bounds().height(), shelf_bounds.height());
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   EXPECT_EQ(GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE),
             display.GetWorkAreaInsets().right());
   EXPECT_EQ(GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE),
             display.bounds().right() - display.work_area().right());
 }
 
 TEST_F(ShelfLayoutManagerTest, GestureEdgeSwipe) {
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
-  views::Widget* widget = new views::Widget;
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  widget->Init(params);
-  widget->Show();
+  views::Widget* widget = CreateTestWidget();
   widget->Maximize();
 
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator(GetEventGenerator());
 
   aura::Window* window = widget->GetNativeWindow();
   layout_manager->LayoutShelf();
 
   // Edge swipe when SHELF_VISIBLE should not change visibility state.
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   generator.GestureEdgeSwipe();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
   // Edge swipe when AUTO_HIDE_HIDDEN should change to AUTO_HIDE_SHOWN.
@@ skipping 78 matching lines @@
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_1->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_2->GetAutoHideState());
 
   monitor_2_generator.GestureEdgeSwipe();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_1->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_2->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_1->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf_2->GetAutoHideState());
 }
 
-#if defined(OS_WIN)
-// RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
-#define MAYBE_GestureDrag DISABLED_GestureDrag
-#else
-#define MAYBE_GestureDrag GestureDrag
-#endif
-
-TEST_F(ShelfLayoutManagerTest, MAYBE_GestureDrag) {
+TEST_F(ShelfLayoutManagerTest, GestureDrag) {
   // Slop is an implementation detail of gesture recognition, and complicates
   // these tests. Ignore it.
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(0);
   Shelf* shelf = GetShelf();
   {
     SCOPED_TRACE("BOTTOM");
     shelf->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
     RunGestureDragTests(gfx::Vector2d(0, 120));
   }
@@ skipping 61 matching lines @@
   window2->SetBounds(gfx::Rect(850, 50, 50, 50));
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
   // Move back to primary display.
   window2->SetBounds(gfx::Rect(50, 50, 50, 50));
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 }
 
 // Test that the shelf animates back to its normal position upon a user
 // completing a gesture drag.
 TEST_F(ShelfLayoutManagerTest, ShelfAnimatesWhenGestureComplete) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Test the shelf animates back to its original visible bounds when it is
   // dragged when there are no visible windows.
   Shelf* shelf = GetShelf();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
   gfx::Rect visible_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
   {
     // Enable animations so that we can make sure that they occur.
     ui::ScopedAnimationDurationScaleMode regular_animations(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
-    ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+    ui::test::EventGenerator& generator(GetEventGenerator());
     gfx::Rect shelf_bounds_in_screen =
         GetShelfWidget()->GetWindowBoundsInScreen();
     gfx::Point start(shelf_bounds_in_screen.CenterPoint());
     gfx::Point end(start.x(), shelf_bounds_in_screen.bottom());
     generator.GestureScrollSequence(start, end,
                                     base::TimeDelta::FromMilliseconds(10), 5);
     EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
     EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
 
     ShelfAnimationWaiter waiter(visible_bounds);
@@ skipping 11 matching lines @@
   gfx::Rect auto_hidden_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
 
   {
     // Enable the animations so that we can make sure they do occur.
     ui::ScopedAnimationDurationScaleMode regular_animations(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
     gfx::Point start =
         GetShelfWidget()->GetWindowBoundsInScreen().CenterPoint();
     gfx::Point end(start.x(), start.y() - 100);
-    ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+    ui::test::EventGenerator& generator(GetEventGenerator());
 
     // Test that the shelf animates to the visible bounds after a swipe up on
     // the auto hidden shelf.
     generator.GestureScrollSequence(start, end,
                                     base::TimeDelta::FromMilliseconds(10), 1);
     EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
     ShelfAnimationWaiter waiter1(visible_bounds);
     waiter1.WaitTillDoneAnimating();
     EXPECT_TRUE(waiter1.WasValidAnimation());
 
@@ skipping 29 matching lines @@
   EXPECT_TRUE(GetSystemTray()->HasSystemBubble());
 }
 
 TEST_F(ShelfLayoutManagerTest, WorkAreaChangeWorkspace) {
   // Make sure the shelf is always visible.
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   layout_manager->LayoutShelf();
 
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.bounds = gfx::Rect(0, 0, 200, 200);
-  params.context = CurrentContext();
-  views::Widget* widget_one = CreateTestWidgetWithParams(params);
+  views::Widget* widget_one = CreateTestWidget();
   widget_one->Maximize();
 
-  views::Widget* widget_two = CreateTestWidgetWithParams(params);
+  views::Widget* widget_two = CreateTestWidget();
   widget_two->Maximize();
   widget_two->Activate();
 
   // Both windows are maximized. They should be of the same size.
   EXPECT_EQ(widget_one->GetNativeWindow()->bounds().ToString(),
             widget_two->GetNativeWindow()->bounds().ToString());
   int area_when_shelf_shown =
       widget_one->GetNativeWindow()->bounds().size().GetArea();
 
   // Now hide the shelf.
@@ skipping 53 matching lines @@
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   StatusAreaWidget* status_area_widget =
       shelf->shelf_widget()->status_area_widget();
   SystemTray* tray = GetSystemTray();
 
   // Create a visible window so auto-hide behavior is enforced.
   CreateTestWidget();
 
   layout_manager->LayoutShelf();
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator(GetEventGenerator());
 
   // Make two iterations - first without a message bubble which should make
   // the shelf disappear and then with a message bubble which should keep it
   // visible.
   for (int i = 0; i < 2; i++) {
     // Make sure the shelf is visible and position the mouse over it. Then
     // allow auto hide.
     shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
     EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
     gfx::Point center =
@@ skipping 63 matching lines @@
 
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   std::unique_ptr<aura::Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
 }
 
-#if defined(OS_CHROMEOS)
-#define MAYBE_StatusAreaHitBoxCoversEdge StatusAreaHitBoxCoversEdge
-#else
-#define MAYBE_StatusAreaHitBoxCoversEdge DISABLED_StatusAreaHitBoxCoversEdge
-#endif
+// Verify the hit bounds of the status area extend to the edge of the shelf.
+TEST_F(ShelfLayoutManagerTest, StatusAreaHitBoxCoversEdge) {
+  Shelf* shelf = GetShelf();
+  StatusAreaWidget* status_area_widget =
+      StatusAreaWidgetTestHelper::GetStatusAreaWidget();
 
-// Verify the hit bounds of the status area extend to the edge of the shelf.
-TEST_F(ShelfLayoutManagerTest, MAYBE_StatusAreaHitBoxCoversEdge) {
-  UpdateDisplay("400x400");
-  Shelf* shelf = GetShelf();
-  StatusAreaWidget* status_area_widget = Shell::GetPrimaryRootWindowController()
-                                             ->shelf_widget()
-                                             ->status_area_widget();
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.MoveMouseTo(399, 399);
+  ui::test::EventGenerator& generator(GetEventGenerator());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  generator.MoveMouseTo(display.bounds().bottom_right());
 
   // Test bottom right pixel for bottom alignment.
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 
   // Test bottom right pixel for right alignment.
   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 
   // Test bottom left pixel for left alignment.
-  generator.MoveMouseTo(0, 399);
+  generator.MoveMouseTo(display.bounds().bottom_left());
   shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 }
 
 // Tests that when the auto-hide behaviour is changed during an animation the
 // target bounds are updated to reflect the new state.
@@ skipping 49 matching lines @@
                                              ->shelf_widget()
                                              ->status_area_widget();
   EXPECT_TRUE(status_area_widget->IsVisible());
   // Shelf should be in the first display's area.
   gfx::Rect status_area_bounds(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_TRUE(gfx::Rect(0, 0, 500, 400).Contains(status_area_bounds));
   EXPECT_EQ(gfx::Point(500, 400), status_area_bounds.bottom_right());
 }
 
 }  // namespace ash