mash: Paritally migrate ShelfLayoutManagerTest to ash common types.

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/test_system_tray_item.h"
@@ skipping 29 matching lines @@
 
 Shelf* GetShelf() {
   return Shelf::ForPrimaryDisplay();
 }
 
 ShelfWidget* GetShelfWidget() {
   return GetShelf()->shelf_widget();
 }
 
 ShelfLayoutManager* GetShelfLayoutManager() {
-  return Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
-}
-
-SystemTray* GetSystemTray() {
-  return Shell::GetPrimaryRootWindowController()->GetSystemTray();
+  return GetShelfWidget()->shelf_layout_manager();
 }
 
 // Class which waits till the shelf finishes animating to the target size and
 // counts the number of animation steps.
 class ShelfAnimationWaiter : views::WidgetObserver {
  public:
   explicit ShelfAnimationWaiter(const gfx::Rect& target_bounds)
       : target_bounds_(target_bounds),
         animation_steps_(0),
         done_waiting_(false) {
@@ skipping 208 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,
@@ skipping 242 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());
-
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   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());
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   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);
+  const int shelf_insets = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
 
-  EXPECT_EQ(root->bounds().bottom() - kShelfAutoHideSize,
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  const int display_bottom = display.bounds().bottom();
+  EXPECT_EQ(display_bottom - kShelfAutoHideSize,
             GetShelfWidget()->GetWindowBoundsInScreen().y());
-  EXPECT_EQ(root->bounds().bottom() - shelf_insets,
-            display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(root)
-                .work_area()
-                .bottom());
+  EXPECT_EQ(display_bottom - shelf_insets, display.work_area().bottom());
 
   // Move the mouse to the bottom of the screen.
-  generator.MoveMouseTo(0, root->bounds().bottom() - 1);
+  generator.MoveMouseTo(0, display_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(),
+  EXPECT_EQ(display_bottom - layout_manager->GetIdealBounds().height(),
             GetShelfWidget()->GetWindowBoundsInScreen().y());
-  EXPECT_EQ(root->bounds().bottom() - shelf_insets,
-            display::Screen::GetScreen()
-                ->GetDisplayNearestWindow(root)
-                .work_area()
-                .bottom());
+  EXPECT_EQ(display_bottom - shelf_insets, 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,
+  EXPECT_EQ(display_bottom - kShelfAutoHideSize,
             GetShelfWidget()->GetWindowBoundsInScreen().y());
 
   // Drag mouse to bottom of screen.
   generator.PressLeftButton();
-  generator.MoveMouseTo(0, root->bounds().bottom() - 1);
+  generator.MoveMouseTo(0, display_bottom - 1);
   UpdateAutoHideStateNow();
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   generator.ReleaseLeftButton();
-  generator.MoveMouseTo(1, root->bounds().bottom() - 1);
+  generator.MoveMouseTo(1, display_bottom - 1);
   UpdateAutoHideStateNow();
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
   generator.PressLeftButton();
-  generator.MoveMouseTo(1, root->bounds().bottom() - 1);
+  generator.MoveMouseTo(1, display_bottom - 1);
   UpdateAutoHideStateNow();
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
 }
 
 // Test the behavior of the shelf when it is auto hidden and it is on the
 // boundary between the primary and the secondary display.
 TEST_F(ShelfLayoutManagerTest, AutoHideShelfOnScreenBoundary) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::RIGHT, 0));
   // Put the primary monitor's shelf on the display boundary.
   Shelf* shelf = GetShelf();
   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
 
   // Create a window because the shelf is always shown when no windows are
   // visible.
   CreateTestWidget();
 
-  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
-  ASSERT_EQ(root_windows[0],
-            GetShelfWidget()->GetNativeWindow()->GetRootWindow());
-
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 
-  int right_edge = root_windows[0]->GetBoundsInScreen().right() - 1;
-  int y = root_windows[0]->GetBoundsInScreen().y();
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  const int right_edge = display.bounds().right() - 1;
+  const int y = display.bounds().y();
 
   // Start off the mouse nowhere near the shelf; the shelf should be hidden.
   ui::test::EventGenerator& generator(GetEventGenerator());
   generator.MoveMouseTo(right_edge - 50, y);
   UpdateAutoHideStateNow();
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   // Moving the mouse over the light bar (but not to the edge of the screen)
   // should show the shelf.
   generator.MoveMouseTo(right_edge - 1, y);
@@ skipping 50 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,
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  EXPECT_EQ(display.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::Screen* screen = display::Screen::GetScreen();
+  EXPECT_EQ(screen->GetPrimaryDisplay().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(screen->GetPrimaryDisplay().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(screen->GetPrimaryDisplay().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());
 
   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();
+  views::Widget* widget = CreateTestWidget();
 
   // 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());
 
   // After maximization, the shelf should be visible and the dimmer created.
   widget->Maximize();
 
@@ skipping 35 matching lines @@
   widget->Restore();
   EXPECT_EQ(-1, shelf_widget->GetDimmingAlphaForTest());
 }
 
 // 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();
+  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);
+    views::Widget::InitParams params;
     params.context = root_window;
     params.bounds = root_window->GetBoundsInScreen();
     params.show_state = ui::SHOW_STATE_MAXIMIZED;
-    widget->Init(params);
-    widget->Show();
+    CreateTestWidgetWithParams(params);
   }
 
   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());
 
   generator.MoveMouseTo(
       shelf_widgets[0]->GetWindowBoundsInScreen().CenterPoint());
   EXPECT_EQ(0, shelf_widgets[0]->GetDimmingAlphaForTest());
   EXPECT_LT(0, shelf_widgets[1]->GetDimmingAlphaForTest());
 
   generator.MoveMouseTo(
       shelf_widgets[1]->GetWindowBoundsInScreen().CenterPoint());
   EXPECT_LT(0, shelf_widgets[0]->GetDimmingAlphaForTest());
   EXPECT_EQ(0, shelf_widgets[1]->GetDimmingAlphaForTest());
 
   generator.MoveMouseTo(root_windows[1]->GetBoundsInScreen().CenterPoint());
   EXPECT_LT(0, shelf_widgets[0]->GetDimmingAlphaForTest());
   EXPECT_LT(0, shelf_widgets[1]->GetDimmingAlphaForTest());
 }
 
 // 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());
+  ui::test::EventGenerator& generator(GetEventGenerator());
   generator.MoveMouseTo(0, 0);
 
   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.
+  views::Widget* widget = CreateTestWidget();
   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());
 
   // Simulate a menu opening.
   shelf_widget->ForceUndimming(true);
 
   // Moving the mouse off the shelf should not dim the bar.
@@ skipping 25 matching lines @@
   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());
   shelf_widget->ForceUndimming(true);
   EXPECT_EQ(0, shelf_widget->GetDimmingAlphaForTest());
 }
 
 // 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 72 matching lines @@
 }
 
 // Makes sure that when we have dual displays, with one or both shelves are set
 // to AutoHide, viewing the AppList on one of them doesn't unhide the other
 // hidden shelf.
 TEST_F(ShelfLayoutManagerTest, DualDisplayOpenAppListWithShelfAutoHideState) {
   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 11 matching lines @@
   window_2->Show();
 
   EXPECT_EQ(shelf_1->shelf_widget()->GetNativeWindow()->GetRootWindow(),
             window_1->GetRootWindow());
   EXPECT_EQ(shelf_2->shelf_widget()->GetNativeWindow()->GetRootWindow(),
             window_2->GetRootWindow());
 
   // Activate one window in one display and manually trigger the update of shelf
   // visibility.
   wm::ActivateWindow(window_1);
-  shell->UpdateShelfVisibility();
+  Shell::GetInstance()->UpdateShelfVisibility();
 
   EXPECT_FALSE(WmShell::Get()->GetAppListTargetVisibility());
   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_HIDDEN, shelf_2->GetAutoHideState());
 
   // Show app list.
   WmShell::Get()->ShowAppList();
-  shell->UpdateShelfVisibility();
+  Shell::GetInstance()->UpdateShelfVisibility();
 
   // Only the shelf in the active display should be shown, the other is hidden.
   EXPECT_TRUE(WmShell::Get()->GetAppListTargetVisibility());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_1->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf_1->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_2->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_2->GetAutoHideState());
 
   // Hide app list, both shelves should be hidden.
   WmShell::Get()->DismissAppList();
@@ skipping 31 matching lines @@
 
   // Hide app list.
   shell->DismissAppList();
   EXPECT_FALSE(shell->GetAppListTargetVisibility());
   EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState());
 }
 
 // Tests the correct behavior of the shelf when there is a system modal window
 // open when we have a single display.
 TEST_F(ShelfLayoutManagerTest, ShelfWithSystemModalWindowSingleDisplay) {
-  Shell* shell = Shell::GetInstance();
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   layout_manager->LayoutShelf();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
   aura::Window* window = CreateTestWindow();
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   window->Show();
   wm::ActivateWindow(window);
 
   // Enable system modal dialog, and make sure shelf is still hidden.
   WmShell* wm_shell = WmShell::Get();
   wm_shell->SimulateModalWindowOpenForTesting(true);
   EXPECT_TRUE(wm_shell->IsSystemModalWindowOpen());
   EXPECT_FALSE(wm::CanActivateWindow(window));
-  shell->UpdateShelfVisibility();
+  Shell::GetInstance()->UpdateShelfVisibility();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 }
 
 // Tests the correct behavior of the shelf when there is a system modal window
 // open when we have dual display.
 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 16 matching lines @@
             window_2->GetRootWindow());
   EXPECT_TRUE(window_1->IsVisible());
   EXPECT_TRUE(window_2->IsVisible());
 
   // Enable system modal dialog, and make sure both shelves are still hidden.
   WmShell* wm_shell = WmShell::Get();
   wm_shell->SimulateModalWindowOpenForTesting(true);
   EXPECT_TRUE(wm_shell->IsSystemModalWindowOpen());
   EXPECT_FALSE(wm::CanActivateWindow(window_1));
   EXPECT_FALSE(wm::CanActivateWindow(window_2));
-  shell->UpdateShelfVisibility();
+  Shell::GetInstance()->UpdateShelfVisibility();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_1->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_1->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_2->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_2->GetAutoHideState());
 }
 
 // Tests that the shelf is only hidden for a fullscreen window at the front and
 // toggles visibility when another window is activated.
 TEST_F(ShelfLayoutManagerTest, FullscreenWindowInFrontHidesShelf) {
   Shelf* shelf = GetShelf();
@@ skipping 18 matching lines @@
   EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState());
 }
 
 // Test the behavior of the shelf when a window on one display is fullscreen
 // but the other display has the active window.
 TEST_F(ShelfLayoutManagerTest, FullscreenWindowOnSecondDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
-  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   Shell::RootWindowControllerList root_window_controllers =
       Shell::GetAllRootWindowControllers();
 
   // Create windows on either display.
   aura::Window* window1 = CreateTestWindow();
   window1->SetBoundsInScreen(gfx::Rect(0, 0, 100, 100),
-                             display_manager->GetDisplayAt(0));
+                             display::Screen::GetScreen()->GetAllDisplays()[0]);
   window1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   window1->Show();
 
   aura::Window* window2 = CreateTestWindow();
   window2->SetBoundsInScreen(gfx::Rect(800, 0, 100, 100),
-                             display_manager->GetDisplayAt(1));
+                             display::Screen::GetScreen()->GetAllDisplays()[1]);
   window2->Show();
 
   EXPECT_EQ(root_windows[0], window1->GetRootWindow());
   EXPECT_EQ(root_windows[1], window2->GetRootWindow());
 
   wm::GetWindowState(window2)->Activate();
   EXPECT_EQ(
       SHELF_HIDDEN,
       root_window_controllers[0]->GetShelfLayoutManager()->visibility_state());
   EXPECT_EQ(
@@ skipping 11 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());
+  EXPECT_EQ(SHELF_ALIGNMENT_LEFT, GetPrimarySystemTray()->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());
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   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());
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   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());
+  EXPECT_EQ(SHELF_ALIGNMENT_RIGHT, GetPrimarySystemTray()->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());
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   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 20 matching lines @@
   EXPECT_TRUE(widget->IsFullscreen());
 }
 
 // Tests that gesture edge swipe events are forwarded to the right shelf on the
 // right monitor (crbug.com/449851).
 TEST_F(ShelfLayoutManagerTest, GestureEdgeSwipeMultiMonitor) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Create two displays.
-  Shell* shell = Shell::GetInstance();
-  DisplayManager* display_manager = shell->display_manager();
   UpdateDisplay("200x200,100x100");
-  ASSERT_EQ(2U, display_manager->GetNumDisplays());
-
   auto root_window_controllers = Shell::GetAllRootWindowControllers();
   ASSERT_EQ(2U, root_window_controllers.size());
   Shelf* shelf_1 = root_window_controllers[0]->GetShelf();
   Shelf* shelf_2 = root_window_controllers[1]->GetShelf();
 
   // Create two maximized windows, one in each display.
   aura::Window* window_1 =
       CreateTestWindowInParent(root_window_controllers[0]->GetRootWindow());
   window_1->SetBounds(gfx::Rect(0, 0, 100, 100));
   window_1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
@@ skipping 20 matching lines @@
       root_window_controllers[1]->GetRootWindow());
 
   // An edge swipe in one display should only affect the shelf in that display.
   monitor_1_generator.GestureEdgeSwipe();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_1->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_2->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf_1->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_2->GetAutoHideState());
 
   // Back to normal after an update.
-  shell->UpdateShelfVisibility();
+  Shell::GetInstance()->UpdateShelfVisibility();
   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_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())

[James Cook, 2016/08/02 16:34:18]

It's great you cleaned up unnecessary stuff like this.

[msw, 2016/08/02 18:12:29]

Acknowledged.

-    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 19 matching lines @@
   // Turn on auto-hide for the shelf.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
   // Show the status menu. That should make the shelf visible again.
   WmShell::Get()->accelerator_controller()->PerformActionIfEnabled(
       SHOW_SYSTEM_TRAY_BUBBLE);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
-  EXPECT_TRUE(GetSystemTray()->HasSystemBubble());
+  EXPECT_TRUE(GetPrimarySystemTray()->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 47 matching lines @@
   EXPECT_FALSE(shelf_widget->GetDimsShelf());
 }
 
 // Make sure that the shelf will not hide if the mouse is between a bubble and
 // the shelf.
 TEST_F(ShelfLayoutManagerTest, BubbleEnlargesShelfMouseHitArea) {
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   StatusAreaWidget* status_area_widget =
       shelf->shelf_widget()->status_area_widget();
-  SystemTray* tray = GetSystemTray();
+  SystemTray* tray = GetPrimarySystemTray();
 
   // 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, 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);
+TEST_F(ShelfLayoutManagerTest, StatusAreaHitBoxCoversEdge) {
+  StatusAreaWidget* status_area_widget = GetShelfWidget()->status_area_widget();
+  ui::test::EventGenerator& generator(GetEventGenerator());
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
+  gfx::Rect inset_display_bounds = display.bounds();
+  inset_display_bounds.Inset(1, 1);
 
   // Test bottom right pixel for bottom alignment.
+  GetShelf()->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
+  generator.MoveMouseTo(inset_display_bounds.bottom_right());
+#if defined(OS_WIN)
+  // The bottom right pixel doesn't work on Windows; see crbug.com/633434
+  generator.MoveMouseTo(
+      status_area_widget->GetWindowBoundsInScreen().CenterPoint());
+#endif

[James Cook, 2016/08/02 16:34:18]

If possible I would just #if !defined(OS_WIN) the EXPECT calls below, rather
than adding an extra move on Windows. I got confused when I first read this.
Same below.

[msw, 2016/08/02 18:12:29]

Done.

   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);
+  GetShelf()->SetAlignment(SHELF_ALIGNMENT_RIGHT);
+  generator.MoveMouseTo(inset_display_bounds.bottom_right());
+#if defined(OS_WIN)
+  // The bottom right pixel doesn't work on Windows; see crbug.com/633434
+  generator.MoveMouseTo(
+      status_area_widget->GetWindowBoundsInScreen().CenterPoint());
+#endif
   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);
-  shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
+  generator.MoveMouseTo(inset_display_bounds.bottom_left());

[James Cook, 2016/08/02 16:34:18]

Doesn't this check 1, 398 instead of 0, 399? (We've had Fitts' Law violation
bugs in the past, which is why this tests the corners.)

[msw, 2016/08/02 18:12:29]

Done. Thanks for catching that!

+  GetShelf()->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.
 TEST_F(ShelfLayoutManagerTest,
        ShelfAutoHideToggleDuringAnimationUpdatesBounds) {
-  Shelf* shelf = GetShelf();
   aura::Window* status_window =
       GetShelfWidget()->status_area_widget()->GetNativeView();
   gfx::Rect initial_bounds = status_window->bounds();
 
   ui::ScopedAnimationDurationScaleMode regular_animations(
       ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
-  shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
+  GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
   gfx::Rect hide_target_bounds = status_window->GetTargetBounds();
   EXPECT_GT(hide_target_bounds.y(), initial_bounds.y());
 
-  shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
+  GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   gfx::Rect reshow_target_bounds = status_window->GetTargetBounds();
   EXPECT_EQ(initial_bounds, reshow_target_bounds);
 }
 
 // Tests that during shutdown, that window activation changes are properly
 // handled, and do not crash (crbug.com/458768)
 TEST_F(ShelfLayoutManagerTest, ShutdownHandlesWindowActivation) {
-  Shelf* shelf = GetShelf();
-  shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
+  GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
   aura::Window* window1 = CreateTestWindowInShellWithId(0);
   window1->SetBounds(gfx::Rect(0, 0, 100, 100));
   window1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   window1->Show();
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(0));
   window2->SetBounds(gfx::Rect(0, 0, 100, 100));
   window2->Show();
   wm::ActivateWindow(window1);
 
   GetShelfWidget()->Shutdown();
 
   // Deleting a focused maximized window will switch focus to |window2|. This
   // would normally cause the ShelfLayoutManager to update its state. However
   // during shutdown we want to handle this without crashing.
   delete window1;
 }
 
 TEST_F(ShelfLayoutManagerTest, ShelfLayoutInUnifiedDesktop) {
   if (!SupportsMultipleDisplays())
     return;
+
   Shell::GetInstance()->display_manager()->SetUnifiedDesktopEnabled(true);
-
   UpdateDisplay("500x400, 500x400");
 
-  StatusAreaWidget* status_area_widget = Shell::GetPrimaryRootWindowController()
-                                             ->shelf_widget()
-                                             ->status_area_widget();
+  StatusAreaWidget* status_area_widget = GetShelfWidget()->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