Reworks the workspace code. Here's the new heuristics:

ash/wm/workspace/workspace_manager_unittest.cc

Index: ash/wm/workspace/workspace_manager_unittest.cc
diff --git a/ash/wm/workspace/workspace_manager_unittest.cc b/ash/wm/workspace/workspace_manager_unittest.cc
index 51df1943d22d53bc06873aa2cd5efa028425b4a1..c8753f056dc3f1f24c7a9808dd25dcd5443a9bd5 100644
--- a/ash/wm/workspace/workspace_manager_unittest.cc
+++ b/ash/wm/workspace/workspace_manager_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -7,7 +7,7 @@
 #include "ash/shell_window_ids.h"
 #include "ash/wm/activation_controller.h"
 #include "ash/wm/workspace/workspace.h"
-#include "ash/wm/workspace/workspace_observer.h"
+#include "ash/wm/workspace/workspace_layout_manager.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/screen_aura.h"
@@ -15,81 +15,27 @@
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 
-namespace {
-using ash::internal::Workspace;
-using ash::internal::WorkspaceManager;
 using aura::Window;
 
-class TestWorkspaceObserver : public ash::internal::WorkspaceObserver {
- public:
-  explicit TestWorkspaceObserver(WorkspaceManager* manager)
-      : manager_(manager),
-        move_source_(NULL),
-        move_target_(NULL),
-        active_workspace_(NULL),
-        old_active_workspace_(NULL) {
-    manager_->AddObserver(this);
-  }
-
-  virtual ~TestWorkspaceObserver() {
-    manager_->RemoveObserver(this);
-  }
-
-  Window* move_source() { return move_source_; }
-  Window* move_target() { return move_target_; }
-  Workspace* active_workspace() { return active_workspace_; }
-  Workspace* old_active_workspace() { return old_active_workspace_; }
-
-  // Resets the observer states.
-  void reset() {
-    active_workspace_ = NULL;
-    old_active_workspace_ = NULL;
-    move_source_ = NULL;
-    move_target_ = NULL;
-  }
-
-  // Overridden from WorkspaceObserver:
-  virtual void WindowMoved(WorkspaceManager* manager,
-                           Window* source,
-                           Window* target) {
-    move_source_ = source;
-    move_target_ = target;
-  }
-  virtual void ActiveWorkspaceChanged(WorkspaceManager* manager,
-                                      Workspace* old) {
-    old_active_workspace_ = old;
-    active_workspace_ = manager->GetActiveWorkspace();
-  }
-
- private:
-  WorkspaceManager* manager_;
-  Window* move_source_;
-  Window* move_target_;
-  Workspace* active_workspace_;
-  Workspace* old_active_workspace_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestWorkspaceObserver);
-};
-
-}  // namespace
-
 namespace ash {
 namespace internal {
 
-class WorkspaceManagerTestBase : public aura::test::AuraTestBase {
+class WorkspaceManagerTest : public aura::test::AuraTestBase {
  public:
-  WorkspaceManagerTestBase() {
+  WorkspaceManagerTest() : layout_manager_(NULL) {
     aura::RootWindow::GetInstance()->set_id(
         internal::kShellWindowId_DefaultContainer);
     activation_controller_.reset(new internal::ActivationController);
     activation_controller_->set_default_container_for_test(
         aura::RootWindow::GetInstance());
   }
-  virtual ~WorkspaceManagerTestBase() {}
+  virtual ~WorkspaceManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     aura::test::AuraTestBase::SetUp();
     manager_.reset(new WorkspaceManager(viewport()));
+    layout_manager_ = new WorkspaceLayoutManager(manager_.get());
+    viewport()->SetLayoutManager(layout_manager_);
   }
 
   virtual void TearDown() OVERRIDE {
@@ -99,468 +45,243 @@ class WorkspaceManagerTestBase : public aura::test::AuraTestBase {
 
   aura::Window* CreateTestWindow() {
     aura::Window* window = new aura::Window(NULL);
-    window->Init(ui::Layer::LAYER_HAS_NO_TEXTURE);
+    window->SetType(aura::client::WINDOW_TYPE_NORMAL);
+    window->Init(ui::Layer::LAYER_HAS_TEXTURE);
+    window->SetParent(viewport());
     return window;
   }
 
   aura::Window* viewport() {
     return aura::RootWindow::GetInstance();
   }
-  scoped_ptr<WorkspaceManager> manager_;
 
- private:
-  scoped_ptr<internal::ActivationController> activation_controller_;
+  const std::vector<Workspace*>& workspaces() const {
+    return manager_->workspaces_;
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(WorkspaceManagerTestBase);
-};
+  gfx::Rect GetWorkAreaBounds() {
+    return manager_->GetWorkAreaBounds();
+  }
 
-class WorkspaceManagerTest : public WorkspaceManagerTestBase {
-};
+  Workspace* active_workspace() {
+    return manager_->active_workspace_;
+  }
 
-TEST_F(WorkspaceManagerTest, WorkspaceManagerCreateAddFind) {
-  scoped_ptr<Window> w1(CreateTestWindow());
-  scoped_ptr<Window> w2(CreateTestWindow());
+  Workspace* FindBy(aura::Window* window) const {
+    return manager_->FindBy(window);
+  }
 
-  Workspace* ws1 = manager_->CreateWorkspace();
-  ws1->AddWindowAfter(w1.get(), NULL);
-  // w2 is not a part of any workspace yet.
-  EXPECT_EQ(NULL, manager_->FindBy(w2.get()));
+  scoped_ptr<WorkspaceManager> manager_;
 
-  // w2 is in ws2 workspace.
-  Workspace* ws2 = manager_->CreateWorkspace();
-  ws2->AddWindowAfter(w2.get(), NULL);
-  EXPECT_EQ(ws2, manager_->FindBy(w2.get()));
+  // Owned by viewport().
+  WorkspaceLayoutManager* layout_manager_;
 
-  // Make sure |FindBy(w1.get())| still returns
-  // correct workspace.
-  EXPECT_EQ(ws1, manager_->FindBy(w1.get()));
+ private:
+  scoped_ptr<internal::ActivationController> activation_controller_;
 
-  // once workspace is gone, w2 shouldn't match
-  // any workspace.
-  delete ws2;
-  EXPECT_EQ(NULL, manager_->FindBy(w2.get()));
+  DISALLOW_COPY_AND_ASSIGN(WorkspaceManagerTest);
+};
 
-  // Reset now before windows are destroyed.
-  manager_.reset();
-}
+// Assertions around adding a normal window.
+TEST_F(WorkspaceManagerTest, AddNormalWindowWhenEmpty) {
+  scoped_ptr<Window> w1(CreateTestWindow());
+  w1->SetBounds(gfx::Rect(0, 0, 250, 251));
 
-TEST_F(WorkspaceManagerTest, LayoutWorkspaces) {
-  manager_->SetWorkspaceSize(gfx::Size(100, 100));
-  EXPECT_EQ("0,0 100x100", viewport()->bounds().ToString());
+  ASSERT_TRUE(manager_->IsManagedWindow(w1.get()));
+  EXPECT_FALSE(FindBy(w1.get()));
 
-  Workspace* ws1 = manager_->CreateWorkspace();
-  manager_->LayoutWorkspaces();
+  w1->Show();
 
-  // ws1 is laied out in left most position.
-  EXPECT_EQ(100, viewport()->bounds().width());
-  EXPECT_EQ("0,0 100x100", ws1->bounds().ToString());
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_TRUE(w1->layer()->visible());
 
-  // ws2 is laied out next to ws1, with 50 margin.
-  Workspace* ws2 = manager_->CreateWorkspace();
-  manager_->LayoutWorkspaces();
+  EXPECT_EQ(250, w1->bounds().width());
+  EXPECT_EQ(251, w1->bounds().height());
 
-  EXPECT_EQ(250, viewport()->bounds().width());
-  EXPECT_EQ("0,0 100x100", ws1->bounds().ToString());
-  EXPECT_EQ("150,0 100x100", ws2->bounds().ToString());
+  // Should be 1 workspace, TYPE_NORNMAL with w1.
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
 }
 
-// Makes sure the bounds of window are resized if the workspace size shrinks.
-TEST_F(WorkspaceManagerTest, ResizeDuringLayout) {
-  manager_->SetWorkspaceSize(gfx::Size(100, 100));
-  EXPECT_EQ("0,0 100x100", viewport()->bounds().ToString());
-
-  Workspace* ws1 = manager_->CreateWorkspace();
+// Assertions around maximizing/unmaximizing.
+TEST_F(WorkspaceManagerTest, SingleMaximizeWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
-  w1->SetBounds(gfx::Rect(0, 0, 100, 100));
-  viewport()->AddChild(w1.get());
-  EXPECT_TRUE(ws1->AddWindowAfter(w1.get(), NULL));
-  manager_->SetWorkspaceSize(gfx::Size(50, 50));
-
-  // ws1 is laied out in left most position.
-  EXPECT_EQ("0,0 50x50", ws1->bounds().ToString());
-  EXPECT_EQ("0,0 50x50", w1->layer()->GetTargetBounds().ToString());
-}
+  w1->SetBounds(gfx::Rect(0, 0, 250, 251));
 
-TEST_F(WorkspaceManagerTest, WorkspaceManagerDragArea) {
-  aura::RootWindow::GetInstance()->screen()->set_work_area_insets(
-      gfx::Insets(10, 10, 10, 10));
-  viewport()->SetBounds(gfx::Rect(0, 0, 200, 200));
-  EXPECT_EQ("10,10 180x180", manager_->GetDragAreaBounds().ToString());
-}
+  ASSERT_TRUE(manager_->IsManagedWindow(w1.get()));
 
-TEST_F(WorkspaceManagerTest, WorkspaceManagerActivate) {
-  TestWorkspaceObserver observer(manager_.get());
-  Workspace* ws1 = manager_->CreateWorkspace();
-  Workspace* ws2 = manager_->CreateWorkspace();
-  EXPECT_EQ(NULL, manager_->GetActiveWorkspace());
-
-  // Activate ws1.
-  ws1->Activate();
-  EXPECT_EQ(ws1, manager_->GetActiveWorkspace());
-  EXPECT_EQ(NULL, observer.old_active_workspace());
-  EXPECT_EQ(ws1, observer.active_workspace());
-  observer.reset();
-
-  // Activate ws2.
-  ws2->Activate();
-  EXPECT_EQ(ws2, manager_->GetActiveWorkspace());
-  EXPECT_EQ(ws1, observer.old_active_workspace());
-  EXPECT_EQ(ws2, observer.active_workspace());
-  observer.reset();
-
-  // Deleting active workspace sets active workspace to NULL.
-  delete ws2;
-  EXPECT_EQ(NULL, manager_->GetActiveWorkspace());
-  EXPECT_EQ(ws2, observer.old_active_workspace());
-  EXPECT_EQ(NULL, observer.active_workspace());
-}
+  w1->Show();
 
-TEST_F(WorkspaceManagerTest, FindRotateWindow) {
-  manager_->SetWorkspaceSize(gfx::Size(500, 300));
-
-  Workspace* ws1 = manager_->CreateWorkspace();
-  scoped_ptr<Window> w11(CreateTestWindow());
-  w11->SetBounds(gfx::Rect(0, 0, 100, 100));
-  ws1->AddWindowAfter(w11.get(), NULL);
-
-  scoped_ptr<Window> w12(CreateTestWindow());
-  w12->SetBounds(gfx::Rect(0, 0, 100, 100));
-  ws1->AddWindowAfter(w12.get(), NULL);
-  manager_->LayoutWorkspaces();
-
-  // Workspaces are 0-<lmgn>-145-<w11>-245-<wmng>-255-<w12>-355-<rmgn>-500.
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(0, 0)));
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(100, 0)));
-  EXPECT_EQ(w11.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(150, 0)));
-  EXPECT_EQ(w12.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(300, 0)));
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(400, 0)));
-
-  w11->SetBounds(gfx::Rect(0, 0, 400, 100));
-  w12->SetBounds(gfx::Rect(0, 0, 200, 100));
-  manager_->FindBy(w11.get())->Layout(NULL);
-  EXPECT_EQ(w11.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(10, 0)));
-  EXPECT_EQ(w11.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(240, 0)));
-  EXPECT_EQ(w12.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(260, 0)));
-  EXPECT_EQ(w12.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(490, 0)));
-
-  Workspace* ws2 = manager_->CreateWorkspace();
-  scoped_ptr<Window> w21(CreateTestWindow());
-  w21->SetBounds(gfx::Rect(0, 0, 100, 100));
-  ws2->AddWindowAfter(w21.get(), NULL);
-  manager_->LayoutWorkspaces();
-
-  // 2nd workspace starts from 500+50 and the window is centered 750-850.
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(600, 0)));
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(740, 0)));
-  EXPECT_EQ(w21.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(760, 0)));
-  EXPECT_EQ(w21.get(),
-            manager_->FindRotateWindowForLocation(gfx::Point(840, 0)));
-  EXPECT_EQ(NULL, manager_->FindRotateWindowForLocation(gfx::Point(860, 0)));
-
-  // Reset now before windows are destroyed.
-  manager_.reset();
-}
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_TRUE(w1->layer()->visible());
 
-TEST_F(WorkspaceManagerTest, RotateWindows) {
-  scoped_ptr<TestWorkspaceObserver> observer(
-      new TestWorkspaceObserver(manager_.get()));
-  Workspace* ws1 = manager_->CreateWorkspace();
-  Workspace* ws2 = manager_->CreateWorkspace();
-
-  scoped_ptr<Window> w11(CreateTestWindow());
-  ws1->AddWindowAfter(w11.get(), NULL);
-
-  scoped_ptr<Window> w21(CreateTestWindow());
-  scoped_ptr<Window> w22(CreateTestWindow());
-  ws2->AddWindowAfter(w21.get(), NULL);
-  ws2->AddWindowAfter(w22.get(), NULL);
-
-  EXPECT_EQ(0, ws1->GetIndexOf(w11.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w21.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w22.get()));
-
-  // Rotate right most to left most.
-  manager_->RotateWindows(w22.get(), w11.get());
-  EXPECT_EQ(w22.get(), observer->move_source());
-  EXPECT_EQ(w11.get(), observer->move_target());
-
-  EXPECT_EQ(0, ws1->GetIndexOf(w22.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w11.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w21.get()));
-
-  // Rotate left most to right most.
-  manager_->RotateWindows(w22.get(), w21.get());
-  EXPECT_EQ(0, ws1->GetIndexOf(w11.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w21.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w22.get()));
-  EXPECT_EQ(w22.get(), observer->move_source());
-  EXPECT_EQ(w21.get(), observer->move_target());
-
-  // Rotate left most to 1st element in 2nd workspace.
-  manager_->RotateWindows(w11.get(), w21.get());
-  EXPECT_EQ(0, ws1->GetIndexOf(w21.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w11.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w22.get()));
-  EXPECT_EQ(w11.get(), observer->move_source());
-  EXPECT_EQ(w21.get(), observer->move_target());
-
-  // Rotate middle to right most.
-  manager_->RotateWindows(w11.get(), w22.get());
-  EXPECT_EQ(0, ws1->GetIndexOf(w21.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w22.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w11.get()));
-  EXPECT_EQ(w11.get(), observer->move_source());
-  EXPECT_EQ(w22.get(), observer->move_target());
-
-  // Rotate middle to left most.
-  manager_->RotateWindows(w22.get(), w21.get());
-  EXPECT_EQ(0, ws1->GetIndexOf(w22.get()));
-  EXPECT_EQ(0, ws2->GetIndexOf(w21.get()));
-  EXPECT_EQ(1, ws2->GetIndexOf(w11.get()));
-  EXPECT_EQ(w22.get(), observer->move_source());
-  EXPECT_EQ(w21.get(), observer->move_target());
-
-  // Reset now before windows are destroyed.
-  observer.reset();
-  manager_.reset();
-}
+  EXPECT_EQ(250, w1->bounds().width());
+  EXPECT_EQ(251, w1->bounds().height());
 
-class WorkspaceTest : public WorkspaceManagerTestBase {
-};
+  // Maximize the window.
+  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 
-TEST_F(WorkspaceTest, WorkspaceBasic) {
-  Workspace* ws = manager_->CreateWorkspace();
-  // Sanity check
-  EXPECT_TRUE(ws->is_empty());
+  // Should be 1 workspace, TYPE_MAXIMIZED with w1.
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(GetWorkAreaBounds().width(), w1->bounds().width());
+  EXPECT_EQ(GetWorkAreaBounds().height(), w1->bounds().height());
 
-  scoped_ptr<Window> w1(CreateTestWindow());
-  scoped_ptr<Window> w2(CreateTestWindow());
-  scoped_ptr<Window> w3(CreateTestWindow());
-  // ws is empty and can accomodate new window.
-  EXPECT_TRUE(ws->CanAdd(w1.get()));
-
-  // Add w1.
-  EXPECT_TRUE(ws->AddWindowAfter(w1.get(), NULL));
-  EXPECT_TRUE(ws->Contains(w1.get()));
-  EXPECT_FALSE(ws->is_empty());
-
-  // The workspac still has room for next window.
-  EXPECT_TRUE(ws->CanAdd(w2.get()));
-  EXPECT_TRUE(ws->AddWindowAfter(w2.get(), NULL));
-  EXPECT_TRUE(ws->Contains(w2.get()));
-
-  // The workspace no longer accepts new window.
-  EXPECT_FALSE(ws->CanAdd(w3.get()));
-  EXPECT_FALSE(ws->AddWindowAfter(w3.get(), NULL));
-  EXPECT_FALSE(ws->Contains(w3.get()));
-
-  // Check if the window has correct layout index.
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(-1, ws->GetIndexOf(w3.get()));
-
-  // w1 is gone, so no index for w2.
-  ws->RemoveWindow(w1.get());
-  EXPECT_EQ(-1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_FALSE(ws->Contains(w1.get()));
-
-  // Add w1 back. w1 now has index = 1.
-  EXPECT_TRUE(ws->AddWindowAfter(w1.get(), w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w1.get()));
-
-  // Reset now before windows are destroyed.
-  manager_.reset();
+  // Restore the window.
+  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
+
+  // Should be 1 workspace, TYPE_NORMAL with w1.
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(250, w1->bounds().width());
+  EXPECT_EQ(251, w1->bounds().height());
 }
 
-TEST_F(WorkspaceTest, RotateWindows) {
-  size_t orig_max = Workspace::SetMaxWindowsCount(3);
-  Workspace* ws = manager_->CreateWorkspace();
+// Assertions around closing the last window in a workspace.
+TEST_F(WorkspaceManagerTest, CloseLastWindowInWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
-  scoped_ptr<Window> w3(CreateTestWindow());
-  ws->AddWindowAfter(w1.get(), NULL);
-  ws->AddWindowAfter(w2.get(), NULL);
-  ws->AddWindowAfter(w3.get(), NULL);
-
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(2, ws->GetIndexOf(w3.get()));
-
-  // Rotate to left.
-  ws->RotateWindows(w1.get(), w3.get());
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(2, ws->GetIndexOf(w1.get()));
-
-  // Rotate to right.
-  ws->RotateWindows(w1.get(), w2.get());
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(2, ws->GetIndexOf(w3.get()));
-
-  // Rotating to the middle from left.
-  ws->RotateWindows(w1.get(), w2.get());
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(2, ws->GetIndexOf(w3.get()));
-
-  // Rotating to the middle from right.
-  ws->RotateWindows(w3.get(), w1.get());
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(2, ws->GetIndexOf(w1.get()));
-
-  // Reset now before windows are destroyed.
-  manager_.reset();
-  Workspace::SetMaxWindowsCount(orig_max);
+  w1->SetBounds(gfx::Rect(0, 0, 250, 251));
+  w1->Show();
+  w2->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  w2->Show();
+
+  // Should be 2 workspaces, TYPE_NORMAL with w1, and TYPE_MAXIMIZED with w2.
+  ASSERT_EQ(2u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[1]->type());
+  ASSERT_EQ(1u, workspaces()[1]->windows().size());
+  EXPECT_EQ(w2.get(), workspaces()[1]->windows()[0]);
+  EXPECT_FALSE(w1->layer()->visible());
+  EXPECT_TRUE(w2->layer()->visible());
+  // TYPE_MAXIMIZED workspace should be active.
+  EXPECT_EQ(workspaces()[1], active_workspace());
+
+  // Close w2.
+  w2.reset();
+
+  // Should have one workspace, TYPE_NORMAL with w1.
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_TRUE(w1->layer()->visible());
+  EXPECT_EQ(workspaces()[0], active_workspace());
 }
 
-TEST_F(WorkspaceTest, ShiftWindowsSingle) {
-  Workspace* ws = manager_->CreateWorkspace();
-  // Single window in a workspace case.
+// Assertions around adding a maximized window when empty.
+TEST_F(WorkspaceManagerTest, AddMaximizedWindowWhenEmpty) {
   scoped_ptr<Window> w1(CreateTestWindow());
-  ws->AddWindowAfter(w1.get(), NULL);
-
-  scoped_ptr<Window> w2(CreateTestWindow());
+  w1->SetBounds(gfx::Rect(0, 0, 250, 251));
+  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  w1->Show();
 
-  // Sanity check.
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-
-  // Insert |w2| at the beginning and shift.
-  aura::Window* overflow =
-      ws->ShiftWindows(
-          w2.get(), w2.get(), NULL, Workspace::SHIFT_TO_RIGHT);
-  EXPECT_EQ(w1.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-
-  // Insert |w1| at the end and shift.
-  overflow = ws->ShiftWindows(
-      w1.get(), w1.get(), NULL, Workspace::SHIFT_TO_LEFT);
-  EXPECT_EQ(w2.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-
-  // Insert |w2| at the begining and shift up to the w1.
-  overflow = ws->ShiftWindows(
-      w2.get(), w1.get(), NULL, Workspace::SHIFT_TO_RIGHT);
-  EXPECT_EQ(NULL, overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-
-  // Insert |w1| at the end and shift up to the w2.
-  overflow = ws->ShiftWindows(
-      w1.get(), w2.get(), NULL, Workspace::SHIFT_TO_LEFT);
-  EXPECT_EQ(NULL, overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-
-  // Reset now before windows are destroyed.
-  manager_.reset();
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_TRUE(w1->layer()->visible());
+  gfx::Rect work_area(
+      gfx::Screen::GetMonitorWorkAreaNearestWindow(w1.get()));
+  EXPECT_EQ(work_area.width(), w1->bounds().width());
+  EXPECT_EQ(work_area.height(), w1->bounds().height());
+
+  // Should be 1 workspace, TYPE_NORNMAL with w1.
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
 }
 
-TEST_F(WorkspaceTest, ShiftWindowsMultiple) {
-  Workspace* ws = manager_->CreateWorkspace();
-  // Single window in a workspace case.
+// Assertions around two windows and toggling one to be maximized.
+TEST_F(WorkspaceManagerTest, MaximizeWithNormalWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
-  ws->AddWindowAfter(w1.get(), NULL);
-  ws->AddWindowAfter(w2.get(), NULL);
-
-  scoped_ptr<Window> w3(CreateTestWindow());
-
-  // Sanity check.
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(-1, ws->GetIndexOf(w3.get()));
-
-  // Insert |w3| at the beginning and shift.
-  aura::Window* overflow =
-      ws->ShiftWindows(w3.get(), w3.get(), NULL,
-                       Workspace::SHIFT_TO_RIGHT);
-  EXPECT_EQ(w2.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w1.get()));
-
-  // Insert |w3| at the end and shift.
-  overflow = ws->ShiftWindows(w2.get(), w2.get(), NULL,
-                              Workspace::SHIFT_TO_LEFT);
-  EXPECT_EQ(w3.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-
-  // Insert |w3| at the begining and shift up to the w1.
-  overflow = ws->ShiftWindows(w3.get(), w1.get(), NULL,
-                              Workspace::SHIFT_TO_RIGHT);
-  EXPECT_EQ(NULL, overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w2.get()));
-
-  // Insert |w1| at the end and shift up to the w2.
-  overflow = ws->ShiftWindows(w1.get(), w2.get(), NULL,
-                              Workspace::SHIFT_TO_LEFT);
-  EXPECT_EQ(NULL, overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w3.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w1.get()));
-
-  scoped_ptr<Window> unused(CreateTestWindow());
-
-  // Insert |w2| at the |w3| and shift to right.
-  overflow = ws->ShiftWindows(w2.get(), unused.get(), w3.get(),
-                              Workspace::SHIFT_TO_RIGHT);
-  EXPECT_EQ(w1.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w3.get()));
-
-  // Insert |w1| at the |w2| and shift to left.
-  overflow = ws->ShiftWindows(w1.get(), unused.get(), w2.get(),
-                              Workspace::SHIFT_TO_LEFT);
-  EXPECT_EQ(w2.get(), overflow);
-  EXPECT_EQ(-1, ws->GetIndexOf(w2.get()));
-  EXPECT_EQ(0, ws->GetIndexOf(w1.get()));
-  EXPECT_EQ(1, ws->GetIndexOf(w3.get()));
-
-  // Reset now before windows are destroyed.
-  manager_.reset();
+  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->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  w2->Show();
+
+  // Should now be two workspaces.
+  ASSERT_EQ(2u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[1]->type());
+  ASSERT_EQ(1u, workspaces()[1]->windows().size());
+  EXPECT_EQ(w2.get(), workspaces()[1]->windows()[0]);
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_FALSE(w1->layer()->visible());
+  ASSERT_TRUE(w2->layer() != NULL);
+  EXPECT_TRUE(w2->layer()->visible());
+
+  gfx::Rect work_area(
+      gfx::Screen::GetMonitorWorkAreaNearestWindow(w1.get()));
+  EXPECT_EQ(work_area.width(), w2->bounds().width());
+  EXPECT_EQ(work_area.height(), w2->bounds().height());
+
+  // Restore w2, which should then go back to one workspace.
+  w2->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
+  ASSERT_EQ(1u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_NORMAL, workspaces()[0]->type());
+  ASSERT_EQ(2u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->windows()[1]);
+  EXPECT_EQ(50, w2->bounds().width());
+  EXPECT_EQ(51, w2->bounds().height());
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_TRUE(w1->layer()->visible());
+  ASSERT_TRUE(w2->layer() != NULL);
+  EXPECT_TRUE(w2->layer()->visible());
 }
 
-TEST_F(WorkspaceTest, ContainsFullscreenWindow) {
-  Workspace* ws = manager_->CreateWorkspace();
+// Assertions around two maximized windows.
+TEST_F(WorkspaceManagerTest, TwoMaximized) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
-  ws->AddWindowAfter(w1.get(), NULL);
-  ws->AddWindowAfter(w2.get(), NULL);
+  w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
-  w2->Show();
-
-  EXPECT_FALSE(ws->ContainsFullscreenWindow());
+  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 
-  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
-  EXPECT_TRUE(ws->ContainsFullscreenWindow());
+  w2->SetBounds(gfx::Rect(0, 0, 50, 51));
+  w2->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  w2->Show();
 
-  w1->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
-  EXPECT_FALSE(ws->ContainsFullscreenWindow());
+  // Should now be two workspaces.
+  ASSERT_EQ(2u, workspaces().size());
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[0]->type());
+  ASSERT_EQ(1u, workspaces()[0]->windows().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->windows()[0]);
+  EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[1]->type());
+  ASSERT_EQ(1u, workspaces()[1]->windows().size());
+  EXPECT_EQ(w2.get(), workspaces()[1]->windows()[0]);
+  ASSERT_TRUE(w1->layer() != NULL);
+  EXPECT_FALSE(w1->layer()->visible());
+  ASSERT_TRUE(w2->layer() != NULL);
+  EXPECT_TRUE(w2->layer()->visible());
+}
 
-  w2->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
-  EXPECT_TRUE(ws->ContainsFullscreenWindow());
+// Makes sure requests to change the bounds of a normal window go through.
+TEST_F(WorkspaceManagerTest, ChangeBoundsOfNormalWindow) {
+  scoped_ptr<Window> w1(CreateTestWindow());
+  w1->Show();
 
-  w2->Hide();
-  EXPECT_FALSE(ws->ContainsFullscreenWindow());
+  EXPECT_TRUE(manager_->IsManagedWindow(w1.get()));
+  // 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());
 }
 
 }  // namespace internal