Remove Shell::shelf()|status_area_widget()|launcher()

ash/wm/workspace/workspace_manager2_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/wm/workspace/workspace_manager2.h"
 
 #include "ash/ash_switches.h"
+#include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/activation_controller.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace2.h"
 #include "ash/wm/workspace_controller_test_helper.h"
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 using aura::Window;
 
 namespace ash {
 namespace internal {
 
-namespace {
-
-bool GetWindowOverlapsShelf() {
-  return Shell::GetInstance()->shelf()->window_overlaps_shelf();
-}
-
-}  // namespace
-
 class WorkspaceManager2Test : public test::AshTestBase {
  public:
   WorkspaceManager2Test() : manager_(NULL) {}
   virtual ~WorkspaceManager2Test() {}
 
   aura::Window* CreateTestWindowUnparented() {
     aura::Window* window = new aura::Window(NULL);
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
@@ skipping 19 matching lines @@
   }
 
   gfx::Rect GetFullscreenBounds(aura::Window* window) {
     return Shell::GetScreen()->GetDisplayNearestWindow(window).bounds();
   }
 
   Workspace2* active_workspace() {
     return manager_->active_workspace_;
   }
 
+  ShelfLayoutManager* shelf_layout_manager() {
+    return Shell::GetPrimaryRootWindowController()->shelf();
+  }
+
+  bool GetWindowOverlapsShelf() {
+    return shelf_layout_manager()->window_overlaps_shelf();
+  }
+
   Workspace2* FindBy(aura::Window* window) const {
     return manager_->FindBy(window);
   }
 
   std::string WorkspaceStateString(Workspace2* workspace) {
     return (workspace->is_maximized() ? "M" : "") +
         base::IntToString(static_cast<int>(
                               workspace->window()->children().size()));
   }
 
@@ skipping 359 matching lines @@
 // updated.
 TEST_F(WorkspaceManager2Test, ShelfStateUpdated) {
   // Since ShelfLayoutManager queries for mouse location, move the mouse so
   // it isn't over the shelf.
   aura::test::EventGenerator generator(
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(0, 0);
 
   scoped_ptr<Window> w1(CreateTestWindow());
   const gfx::Rect w1_bounds(0, 1, 101, 102);
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   const gfx::Rect touches_shelf_bounds(
       0, shelf->GetIdealBounds().y() - 10, 101, 102);
   // Move |w1| to overlap the shelf.
   w1->SetBounds(touches_shelf_bounds);
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   // A visible ignored window should not trigger the overlap.
   scoped_ptr<Window> w_ignored(CreateTestWindow());
   w_ignored->SetBounds(touches_shelf_bounds);
@@ skipping 194 matching lines @@
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_FALSE(w1->IsVisible());
   w1->Show();
   EXPECT_TRUE(w1->IsVisible());
 }
 
 // Test that we report we're in the fullscreen state even if the fullscreen
 // window isn't being managed by us (http://crbug.com/123931).
 TEST_F(WorkspaceManager2Test, GetWindowStateWithUnmanagedFullscreenWindow) {
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
 
   // We need to create a regular window first so there's an active workspace.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
 
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
@@ skipping 22 matching lines @@
   w2.reset();
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(ShelfLayoutManager::VISIBLE, shelf->visibility_state());
   EXPECT_EQ(WORKSPACE_WINDOW_STATE_DEFAULT, manager_->GetWindowState());
 }
 
 // Variant of GetWindowStateWithUnmanagedFullscreenWindow that uses a maximized
 // window rather than a normal window.
 TEST_F(WorkspaceManager2Test,
        GetWindowStateWithUnmanagedFullscreenWindowWithMaximized) {
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 
   // Make the first window maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
 
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   SetPersistsAcrossAllWorkspaces(
@@ skipping 44 matching lines @@
 
 // Verifies going from maximized to minimized sets the right state for painting
 // the background of the launcher.
 TEST_F(WorkspaceManager2Test, MinimizeResetsVisibility) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_EQ(ShelfLayoutManager::VISIBLE,
-            Shell::GetInstance()->shelf()->visibility_state());
-  EXPECT_FALSE(Shell::GetInstance()->launcher()->paints_background());
+            shelf_layout_manager()->visibility_state());
+  EXPECT_FALSE(Launcher::ForPrimaryDisplay()->paints_background());
 }
 
 // Verifies transients are moved when maximizing.
 TEST_F(WorkspaceManager2Test, MoveTransientOnMaximize) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->AddTransientChild(w2.get());
   w2->Show();
   wm::ActivateWindow(w1.get());
@@ skipping 79 matching lines @@
   EXPECT_TRUE(w1->IsVisible());
 }
 
 // Verifies windows that are offscreen don't move when switching workspaces.
 TEST_F(WorkspaceManager2Test, DontMoveOnSwitch) {
   aura::test::EventGenerator generator(
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(0, 0);
 
   scoped_ptr<Window> w1(CreateTestWindow());
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
   const gfx::Rect touches_shelf_bounds(
       0, shelf->GetIdealBounds().y() - 10, 101, 102);
   // Move |w1| to overlap the shelf.
   w1->SetBounds(touches_shelf_bounds);
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // Create another window and maximize it.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Switch to w1.
   wm::ActivateWindow(w1.get());
   EXPECT_EQ(touches_shelf_bounds.ToString(), w1->bounds().ToString());
 }
 
 // Verifies that windows that are completely offscreen move when switching
 // workspaces.
 TEST_F(WorkspaceManager2Test, MoveOnSwitch) {
   aura::test::EventGenerator generator(
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(0, 0);
 
   scoped_ptr<Window> w1(CreateTestWindow());
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
   const gfx::Rect w1_bounds(0, shelf->GetIdealBounds().y(), 100, 200);
   // Move |w1| so that the top edge is the same as the top edge of the shelf.
   w1->SetBounds(w1_bounds);
   w1->Show();
   wm::ActivateWindow(w1.get());
   EXPECT_EQ(w1_bounds.ToString(), w1->bounds().ToString());
 
   // Create another window and maximize it.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
@@ skipping 59 matching lines @@
 
 }  // namespace
 
 // Exercises possible crash in W2. Here's the sequence:
 // . minimize a maximized window.
 // . remove the window (which happens when switching displays).
 // . add the window back.
 // . show the window and during the bounds change activate it.
 TEST_F(WorkspaceManager2Test, DontCrashOnChangeAndActivate) {
   // Force the shelf
-  ShelfLayoutManager* shelf = Shell::GetInstance()->shelf();
+  ShelfLayoutManager* shelf = shelf_layout_manager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 
   DontCrashOnChangeAndActivateDelegate delegate;
   scoped_ptr<Window> w1(
       CreateTestWindowWithDelegate(&delegate, 1000, gfx::Rect(10, 11, 250, 251),
                                    NULL));
   w1->Show();
   wm::ActivateWindow(w1.get());
   wm::MaximizeWindow(w1.get());
   wm::MinimizeWindow(w1.get());
@@ skipping 94 matching lines @@
   EXPECT_EQ(w1->parent(), w2->parent());
   ASSERT_EQ("0 M2 active=1", StateString());
 
   // Activate |w1|, should result in dropping |w2| to the desktop.
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("1 M1 active=1", StateString());
 }
 
 }  // namespace internal
 }  // namespace ash