Renames Workspace*2 -> Workspace*.

ash/wm/workspace/workspace_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/wm/workspace/workspace_manager2.h"
+#include "ash/wm/workspace/workspace_manager.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/system/status_area_widget.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/workspace.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 {
 
-class WorkspaceManager2Test : public test::AshTestBase {
+class WorkspaceManagerTest : public test::AshTestBase {
  public:
-  WorkspaceManager2Test() : manager_(NULL) {}
-  virtual ~WorkspaceManager2Test() {}
+  WorkspaceManagerTest() : manager_(NULL) {}
+  virtual ~WorkspaceManagerTest() {}
 
   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);
     return window;
   }
 
   aura::Window* CreateTestWindow() {
     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);
     window->SetParent(NULL);
     return window;
   }
 
   aura::Window* GetViewport() {
     return Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                kShellWindowId_DefaultContainer);
   }
 
-  const std::vector<Workspace2*>& workspaces() const {
+  const std::vector<Workspace*>& workspaces() const {
     return manager_->workspaces_;
   }
 
   gfx::Rect GetFullscreenBounds(aura::Window* window) {
     return Shell::GetScreen()->GetDisplayNearestWindow(window).bounds();
   }
 
-  Workspace2* active_workspace() {
+  Workspace* 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 {
+  Workspace* FindBy(aura::Window* window) const {
     return manager_->FindBy(window);
   }
 
-  std::string WorkspaceStateString(Workspace2* workspace) {
+  std::string WorkspaceStateString(Workspace* workspace) {
     return (workspace->is_maximized() ? "M" : "") +
         base::IntToString(static_cast<int>(
                               workspace->window()->children().size()));
   }
 
   int active_index() {
     return static_cast<int>(
         manager_->FindWorkspace(manager_->active_workspace_) -
         manager_->workspaces_.begin());
   }
 
   std::string StateString() {
     std::string result;
     for (size_t i = 0; i < manager_->workspaces_.size(); ++i) {
       if (i > 0)
         result += " ";
       result += WorkspaceStateString(manager_->workspaces_[i]);
     }
 
     if (!manager_->pending_workspaces_.empty()) {
       result += " P=";
-      for (std::set<Workspace2*>::const_iterator i =
+      for (std::set<Workspace*>::const_iterator i =
                manager_->pending_workspaces_.begin();
            i != manager_->pending_workspaces_.end(); ++i) {
         if (i != manager_->pending_workspaces_.begin())
           result += " ";
         result += WorkspaceStateString(*i);
       }
     }
 
     result += " active=" + base::IntToString(active_index());
     return result;
   }
 
   // Overridden from AshTestBase:
   virtual void SetUp() OVERRIDE {
     test::AshTestBase::SetUp();
     WorkspaceControllerTestHelper workspace_helper(
         Shell::TestApi(Shell::GetInstance()).workspace_controller());
-    manager_ = workspace_helper.workspace_manager2();
+    manager_ = workspace_helper.workspace_manager();
   }
 
   virtual void TearDown() OVERRIDE {
     manager_ = NULL;
     test::AshTestBase::TearDown();
   }
 
  protected:
-  WorkspaceManager2* manager_;
+  WorkspaceManager* manager_;
 
  private:
   scoped_ptr<ActivationController> activation_controller_;
 
-  DISALLOW_COPY_AND_ASSIGN(WorkspaceManager2Test);
+  DISALLOW_COPY_AND_ASSIGN(WorkspaceManagerTest);
 };
 
 // Assertions around adding a normal window.
-TEST_F(WorkspaceManager2Test, AddNormalWindowWhenEmpty) {
+TEST_F(WorkspaceManagerTest, AddNormalWindowWhenEmpty) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
 
   EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL);
 
   w1->Show();
 
   EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL);
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
 
   EXPECT_EQ("0,0 250x251", w1->bounds().ToString());
 
   // Should be 1 workspace for the desktop, not maximized.
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
 }
 
 // Assertions around maximizing/unmaximizing.
-TEST_F(WorkspaceManager2Test, SingleMaximizeWindow) {
+TEST_F(WorkspaceManagerTest, SingleMaximizeWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
 
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
@@ skipping 16 matching lines @@
   // Restore the window.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 
   // Should be 1 workspace for the desktop.
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ("0,0 250x251", w1->bounds().ToString());
 }
 
 // Assertions around closing the last window in a workspace.
-TEST_F(WorkspaceManager2Test, CloseLastWindowInWorkspace) {
+TEST_F(WorkspaceManagerTest, CloseLastWindowInWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w1.get());
 
   // Should be 1 workspace and 1 pending, !maximized and maximized. The second
   // workspace is pending since the window wasn't active.
   ASSERT_EQ("1 P=M1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
 
   // Close w2.
   w2.reset();
 
   // Should have one workspace.
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_TRUE(w1->IsVisible());
 }
 
 // Assertions around adding a maximized window when empty.
-TEST_F(WorkspaceManager2Test, AddMaximizedWindowWhenEmpty) {
+TEST_F(WorkspaceManagerTest, AddMaximizedWindowWhenEmpty) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
   gfx::Rect work_area(
       ScreenAsh::GetMaximizedWindowBoundsInParent(w1.get()));
   EXPECT_EQ(work_area.width(), w1->bounds().width());
   EXPECT_EQ(work_area.height(), w1->bounds().height());
 
   // Should be 2 workspaces (since we always keep the desktop).
   ASSERT_EQ("0 M1 active=1", StateString());
   EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
 }
 
 // Assertions around two windows and toggling one to be maximized.
-TEST_F(WorkspaceManager2Test, MaximizeWithNormalWindow) {
+TEST_F(WorkspaceManagerTest, MaximizeWithNormalWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
 
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
@@ skipping 13 matching lines @@
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("2 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
   EXPECT_EQ(50, w2->bounds().width());
   EXPECT_EQ(51, w2->bounds().height());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 }
 
 // Assertions around two maximized windows.
-TEST_F(WorkspaceManager2Test, TwoMaximized) {
+TEST_F(WorkspaceManagerTest, TwoMaximized) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   ASSERT_EQ("1 M1 active=1", StateString());
 
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->Show();
   wm::ActivateWindow(w2.get());
   ASSERT_EQ("1 M1 active=0", StateString());
 
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   ASSERT_EQ("0 M1 M1 active=2", StateString());
 
   // The last stacked window (|w2|) should be last since it was maximized last.
   EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
   EXPECT_EQ(w2.get(), workspaces()[2]->window()->children()[0]);
 }
 
 // Makes sure requests to change the bounds of a normal window go through.
-TEST_F(WorkspaceManager2Test, ChangeBoundsOfNormalWindow) {
+TEST_F(WorkspaceManagerTest, ChangeBoundsOfNormalWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
 
   // Setting the bounds should go through since the window is in the normal
   // workspace.
   w1->SetBounds(gfx::Rect(0, 0, 200, 500));
   EXPECT_EQ(200, w1->bounds().width());
   EXPECT_EQ(500, w1->bounds().height());
 }
 
 // Verifies the bounds is not altered when showing and grid is enabled.
-TEST_F(WorkspaceManager2Test, SnapToGrid) {
+TEST_F(WorkspaceManagerTest, SnapToGrid) {
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   w1->SetBounds(gfx::Rect(1, 6, 25, 30));
   w1->SetParent(NULL);
   // We are not aligning this anymore this way. When the window gets shown
   // the window is expected to be handled differently, but this cannot be
   // tested with this test. So the result of this test should be that the
   // bounds are exactly as passed in.
   EXPECT_EQ("1,6 25x30", w1->bounds().ToString());
 }
 
 // Assertions around a fullscreen window.
-TEST_F(WorkspaceManager2Test, SingleFullscreenWindow) {
+TEST_F(WorkspaceManagerTest, SingleFullscreenWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   // Make the window fullscreen.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // Should be 2 workspaces, normal and maximized.
   ASSERT_EQ("0 M1 active=1", StateString());
   EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
@@ skipping 15 matching lines @@
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   ASSERT_EQ("0 M1 active=1", StateString());
   EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
   EXPECT_EQ(GetFullscreenBounds(w1.get()).width(), w1->bounds().width());
   EXPECT_EQ(GetFullscreenBounds(w1.get()).height(), w1->bounds().height());
   ASSERT_TRUE(GetRestoreBoundsInScreen(w1.get()));
   EXPECT_EQ("0,0 250x251", GetRestoreBoundsInScreen(w1.get())->ToString());
 }
 
 // Makes sure switching workspaces doesn't show transient windows.
-TEST_F(WorkspaceManager2Test, DontShowTransientsOnSwitch) {
+TEST_F(WorkspaceManagerTest, DontShowTransientsOnSwitch) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
 
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w2->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->AddTransientChild(w2.get());
 
   w1->Show();
 
   scoped_ptr<Window> w3(CreateTestWindow());
   w3->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w3->Show();
   wm::ActivateWindow(w3.get());
 
   EXPECT_FALSE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
   EXPECT_TRUE(w3->layer()->IsDrawn());
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
   EXPECT_FALSE(w3->layer()->IsDrawn());
 }
 
 // Assertions around minimizing a single window.
-TEST_F(WorkspaceManager2Test, MinimizeSingleWindow) {
+TEST_F(WorkspaceManagerTest, MinimizeSingleWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
 
   w1->Show();
   ASSERT_EQ("1 active=0", StateString());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_FALSE(w1->layer()->IsDrawn());
 
   // Show the window.
   w1->Show();
   EXPECT_TRUE(wm::IsWindowNormal(w1.get()));
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_TRUE(w1->layer()->IsDrawn());
 }
 
 // Assertions around minimizing a maximized window.
-TEST_F(WorkspaceManager2Test, MinimizeMaximizedWindow) {
+TEST_F(WorkspaceManagerTest, MinimizeMaximizedWindow) {
   // Two windows, w1 normal, w2 maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->Show();
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
   ASSERT_EQ("1 M1 active=1", StateString());
 
   // Minimize w2.
@@ skipping 23 matching lines @@
   // Make the window normal.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("2 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
   EXPECT_TRUE(w2->layer()->IsDrawn());
 }
 
 // Verifies ShelfLayoutManager's visibility/auto-hide state is correctly
 // updated.
-TEST_F(WorkspaceManager2Test, ShelfStateUpdated) {
+TEST_F(WorkspaceManagerTest, 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 = shelf_layout_manager();
   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
@@ skipping 110 matching lines @@
   // the window isn't in the visible workspace.
   w1->SetBounds(touches_shelf_bounds);
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   // Activate w1. Since w1 is visible the overlap state should be true.
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(GetWindowOverlapsShelf());
 }
 
 // Verifies persist across all workspaces.
-TEST_F(WorkspaceManager2Test, PersistAcrossAllWorkspaces) {
+TEST_F(WorkspaceManagerTest, PersistAcrossAllWorkspaces) {
   // Create a maximized window.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("0 M1 active=1", StateString());
 
   // Create a window that persists across all workspaces. It should be placed in
   // the current maximized workspace.
   scoped_ptr<Window> w2(CreateTestWindow());
@@ skipping 26 matching lines @@
   ASSERT_EQ("1 P=M1 active=0", StateString());
   wm::ActivateWindow(w2.get());
   ASSERT_EQ("1 P=M1 active=0", StateString());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   ASSERT_EQ("1 P=M1 active=0", StateString());
   EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[0]);
 }
 
 // Verifies that when a window persists across all workpaces is activated that
 // it moves to the current workspace.
-TEST_F(WorkspaceManager2Test, ActivatePersistAcrossAllWorkspacesWhenNotActive) {
+TEST_F(WorkspaceManagerTest, ActivatePersistAcrossAllWorkspacesWhenNotActive) {
   // Create a window that persists across all workspaces.
   scoped_ptr<Window> w2(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
   ASSERT_EQ("1 active=0", StateString());
 
   // Create a maximized window.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("1 M1 active=1", StateString());
 
   // Activate the persists across all workspace window. It should move to the
   // current workspace.
   wm::ActivateWindow(w2.get());
   ASSERT_EQ("0 M2 active=1", StateString());
   // The window that persists across all workspaces should be moved to the top
   // of the stacking order.
   EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
   EXPECT_EQ(w2.get(), workspaces()[1]->window()->children()[1]);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 }
 
 // Verifies Show()ing a minimized window that persists across all workspaces
 // unminimizes the window.
-TEST_F(WorkspaceManager2Test, ShowMinimizedPersistWindow) {
+TEST_F(WorkspaceManagerTest, ShowMinimizedPersistWindow) {
   // Create a window that persists across all workspaces.
   scoped_ptr<Window> w1(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w1.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w1->Show();
   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) {
+TEST_F(WorkspaceManagerTest, GetWindowStateWithUnmanagedFullscreenWindow) {
   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(),
@@ skipping 21 matching lines @@
   EXPECT_EQ(WORKSPACE_WINDOW_STATE_FULL_SCREEN, manager_->GetWindowState());
 
   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,
+TEST_F(WorkspaceManagerTest,
        GetWindowStateWithUnmanagedFullscreenWindowWithMaximized) {
   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());
@@ skipping 18 matching lines @@
   EXPECT_EQ(ShelfLayoutManager::HIDDEN, shelf->visibility_state());
   EXPECT_EQ(WORKSPACE_WINDOW_STATE_FULL_SCREEN,
             manager_->GetWindowState());
 
   w2.reset();
   EXPECT_EQ(ShelfLayoutManager::VISIBLE, shelf->visibility_state());
 }
 
 // Verifies a window marked as persisting across all workspaces ends up in its
 // own workspace when maximized.
-TEST_F(WorkspaceManager2Test, MaximizeDontPersistEndsUpInOwnWorkspace) {
+TEST_F(WorkspaceManagerTest, MaximizeDontPersistEndsUpInOwnWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
 
   SetPersistsAcrossAllWorkspaces(
       w1.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w1->Show();
 
   ASSERT_EQ("1 active=0", StateString());
 
   // Maximize should trigger containing the window.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   ASSERT_EQ("0 P=M1 active=0", StateString());
 
   // And resetting to normal should remove it.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("1 active=0", StateString());
 }
 
 // Verifies going from maximized to minimized sets the right state for painting
 // the background of the launcher.
-TEST_F(WorkspaceManager2Test, MinimizeResetsVisibility) {
+TEST_F(WorkspaceManagerTest, 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,
             shelf_layout_manager()->visibility_state());
   EXPECT_FALSE(Launcher::ForPrimaryDisplay()->paints_background());
 }
 
 // Verifies transients are moved when maximizing.
-TEST_F(WorkspaceManager2Test, MoveTransientOnMaximize) {
+TEST_F(WorkspaceManagerTest, MoveTransientOnMaximize) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->AddTransientChild(w2.get());
   w2->Show();
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("2 active=0", StateString());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   ASSERT_EQ("0 M2 active=1", StateString());
@@ skipping 12 matching lines @@
   // up in pending.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   ASSERT_EQ("0 P=M3 active=0", StateString());
 
   // Restore and everything should go back to the first workspace.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("3 active=0", StateString());
 }
 
 // Verifies window visibility during various workspace changes.
-TEST_F(WorkspaceManager2Test, VisibilityTests) {
+TEST_F(WorkspaceManagerTest, VisibilityTests) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_EQ(1.0f, w1->layer()->GetCombinedOpacity());
 
   // Create another window, activate it and maximized it.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->Show();
   wm::ActivateWindow(w2.get());
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
@@ skipping 36 matching lines @@
   EXPECT_EQ(1.0f, w2->layer()->GetCombinedOpacity());
   EXPECT_FALSE(w1->IsVisible());
 
   // Close |w2|.
   w2.reset();
   EXPECT_EQ(1.0f, w1->layer()->GetCombinedOpacity());
   EXPECT_TRUE(w1->IsVisible());
 }
 
 // Verifies windows that are offscreen don't move when switching workspaces.
-TEST_F(WorkspaceManager2Test, DontMoveOnSwitch) {
+TEST_F(WorkspaceManagerTest, DontMoveOnSwitch) {
   aura::test::EventGenerator generator(
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(0, 0);
 
   scoped_ptr<Window> w1(CreateTestWindow());
   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) {
+TEST_F(WorkspaceManagerTest, MoveOnSwitch) {
   aura::test::EventGenerator generator(
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(0, 0);
 
   scoped_ptr<Window> w1(CreateTestWindow());
   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();
@@ skipping 12 matching lines @@
   gfx::Size size(shelf->status_area_widget()->GetWindowBoundsInScreen().size());
   size.Enlarge(0, 30);
   shelf->status_area_widget()->SetSize(size);
 
   // Switch to w1. The window should have moved.
   wm::ActivateWindow(w1.get());
   EXPECT_NE(w1_bounds.ToString(), w1->bounds().ToString());
 }
 
 // Verifies Focus() works in a window that isn't in the active workspace.
-TEST_F(WorkspaceManager2Test, FocusOnFullscreenInSeparateWorkspace) {
+TEST_F(WorkspaceManagerTest, FocusOnFullscreenInSeparateWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(10, 11, 250, 251));
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   w2->Show();
   EXPECT_FALSE(w2->IsVisible());
@@ skipping 30 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DontCrashOnChangeAndActivateDelegate);
 };
 
 }  // 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) {
+TEST_F(WorkspaceManagerTest, DontCrashOnChangeAndActivate) {
   // Force the 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());
 
   w1->parent()->RemoveChild(w1.get());
 
   // Do this so that when we Show() the window a resize occurs and we make the
   // window active.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
   w1->SetParent(NULL);
   delegate.set_window(w1.get());
   w1->Show();
 }
 
 // Verifies a window with a transient parent not managed by workspace works.
-TEST_F(WorkspaceManager2Test, TransientParent) {
+TEST_F(WorkspaceManagerTest, TransientParent) {
   // Normal window with no transient parent.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Window with a transient parent. We set the transient parent to the root,
   // which would never happen but is enough to exercise the bug.
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   Shell::GetInstance()->GetPrimaryRootWindow()->AddTransientChild(w1.get());
   w1->SetBounds(gfx::Rect(10, 11, 250, 251));
   w1->SetParent(NULL);
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // The window with the transient parent should get added to the same parent as
   // the normal window.
   EXPECT_EQ(w2->parent(), w1->parent());
 }
 
 // Verifies changing TrackedByWorkspace works.
-TEST_F(WorkspaceManager2Test, TrackedByWorkspace) {
+TEST_F(WorkspaceManagerTest, TrackedByWorkspace) {
   // Create a window maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create a second window maximized and mark it not tracked by workspace
   // manager.
@@ skipping 21 matching lines @@
   // workspace.
   SetTrackedByWorkspace(w2.get(), true);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_FALSE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_NE(w1->parent(), w2->parent());
 }
 
 // Verifies a window marked as persisting across all workspaces ends up in its
 // own workspace when maximized.
-TEST_F(WorkspaceManager2Test, DeactivateDropsToDesktop) {
+TEST_F(WorkspaceManagerTest, DeactivateDropsToDesktop) {
   // Create a window maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create another window that persists across all workspaces. It should end
   // up with the same parent as |w1|.
   scoped_ptr<Window> w2(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
   wm::ActivateWindow(w2.get());
   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());
 }
 
 // Test the basic auto placement of one and or two windows in a "simulated
 // session" of sequential window operations.
-TEST_F(WorkspaceManager2Test, BasicAutoPlacing) {
+TEST_F(WorkspaceManagerTest, BasicAutoPlacing) {
   // Test 1: In case there is no manageable window, no window should shift.
 
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   // Trigger the auto window placement function by making it visible.
@@ skipping 58 matching lines @@
   window1->Hide();
   window1->Show();
   // |window1| should be centered.
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
 }
 
 // Test the proper usage of user window movement interaction.
-TEST_F(WorkspaceManager2Test, TestUserMovedWindowRepositioning) {
+TEST_F(WorkspaceManagerTest, TestUserMovedWindowRepositioning) {
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
   ash::wm::SetWindowPositionManaged(window1.get(), true);
@@ skipping 26 matching lines @@
   // Going back to one shown window should keep the state.
   ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), true);
   window2->Hide();
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_TRUE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
 }
 
 // Test that a window from normal to minimize will repos the remaining.
-TEST_F(WorkspaceManager2Test, ToMinimizeRepositionsRemaining) {
+TEST_F(WorkspaceManagerTest, ToMinimizeRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   ash::wm::MinimizeWindow(window1.get());
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 
   ash::wm::RestoreWindow(window1.get());
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // Test that minimizing an initially maximized window will repos the remaining.
-TEST_F(WorkspaceManager2Test, MaxToMinRepositionsRemaining) {
+TEST_F(WorkspaceManagerTest, MaxToMinRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   ash::wm::MaximizeWindow(window1.get());
   ash::wm::MinimizeWindow(window1.get());
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, minimizing will repos the remaining.
-TEST_F(WorkspaceManager2Test, NormToMaxToMinRepositionsRemaining) {
+TEST_F(WorkspaceManagerTest, NormToMaxToMinRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
@@ skipping 13 matching lines @@
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, normal will repos the remaining.
-TEST_F(WorkspaceManager2Test, NormToMaxToNormRepositionsRemaining) {
+TEST_F(WorkspaceManagerTest, NormToMaxToNormRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   ash::wm::SetWindowPositionManaged(window1.get(), true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   ash::wm::SetWindowPositionManaged(window2.get(), true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
@@ skipping 12 matching lines @@
   ash::wm::RestoreWindow(window1.get());
 
   // |window1| should be flush right and |window2| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // Test that animations are triggered.
-TEST_F(WorkspaceManager2Test, AnimatedNormToMaxToNormRepositionsRemaining) {
+TEST_F(WorkspaceManagerTest, AnimatedNormToMaxToNormRepositionsRemaining) {
   ui::LayerAnimator::set_disable_animations_for_test(false);
   scoped_ptr<aura::Window> window1(
       aura::test::CreateTestWindowWithId(0, NULL));
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
   scoped_ptr<aura::Window> window2(
       aura::test::CreateTestWindowWithId(1, NULL));
   window2->Hide();
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
@@ skipping 18 matching lines @@
   window2->layer()->GetAnimator()->StopAnimating();
   // |window1| should be flush right and |window2| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 }  // namespace internal
 }  // namespace ash