Drag and rotate windows

ui/aura_shell/workspace/workspace_manager_unittest.cc

 // Copyright (c) 2011 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 "ui/aura_shell/workspace/workspace_manager.h"
 #include "ui/aura_shell/workspace/workspace.h"
 
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/test_desktop_delegate.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 
 namespace {
 
 class WorkspaceManagerTestBase : public aura::test::AuraTestBase {
  public:
+  virtual void SetUp() OVERRIDE {
+    aura::test::AuraTestBase::SetUp();
+    manager_.reset(new aura_shell::WorkspaceManager(viewport()));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    manager_.reset();
+    aura::test::AuraTestBase::TearDown();
+  }
+
   aura::Window* CreateTestWindow() {
     aura::Window* window = new aura::Window(NULL);
     window->Init(ui::Layer::LAYER_HAS_NO_TEXTURE);
     return window;
   }
 
   aura::Window* viewport() {
     return GetTestDesktopDelegate()->default_container();
   }
+  scoped_ptr<aura_shell::WorkspaceManager> manager_;
 };

[sky, 2011/10/27 19:46:41]

DISALLOW_COPY_AND_ASSIGN

[oshima, 2011/10/27 20:25:43]

Done.

 
 }  // namespace
 
 namespace aura_shell {
 
 using aura::Window;
 using aura_shell::Workspace;
 using aura_shell::WorkspaceManager;
 
 class WorkspaceManagerTest : public WorkspaceManagerTestBase {
 };
 
 TEST_F(WorkspaceManagerTest, WorkspaceManagerCreateAddFind) {
-  WorkspaceManager manager(viewport());
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
 
-  Workspace* ws1 = manager.CreateWorkspace();
+  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()));
+  EXPECT_EQ(NULL, manager_->FindBy(w2.get()));
 
   // w2 is in ws2 workspace.
-  Workspace* ws2 = manager.CreateWorkspace();
+  Workspace* ws2 = manager_->CreateWorkspace();
   ws2->AddWindowAfter(w2.get(), NULL);
-  EXPECT_EQ(ws2, manager.FindBy(w2.get()));
+  EXPECT_EQ(ws2, manager_->FindBy(w2.get()));
 
   // Make sure |FindBy(w1.get())| still returns
   // correct workspace.
-  EXPECT_EQ(ws1, manager.FindBy(w1.get()));
+  EXPECT_EQ(ws1, manager_->FindBy(w1.get()));
 
   // once workspace is gone, w2 shouldn't match
   // any workspace.
   delete ws2;
-  EXPECT_EQ(NULL, manager.FindBy(w2.get()));
+  EXPECT_EQ(NULL, manager_->FindBy(w2.get()));
+
+  // Reset now before windows are destroyed.
+  manager_.reset();
 }
 
 TEST_F(WorkspaceManagerTest, LayoutWorkspaces) {
-  WorkspaceManager manager(viewport());
-  manager.workspace_size_ = gfx::Size(100, 100);
-  manager.LayoutWorkspaces();
+  manager_->workspace_size_ = gfx::Size(100, 100);
+  manager_->LayoutWorkspaces();
   EXPECT_EQ("0,0 100x100", viewport()->bounds().ToString());
 
-  Workspace* ws1 = manager.CreateWorkspace();
-  manager.LayoutWorkspaces();
+  Workspace* ws1 = manager_->CreateWorkspace();
+  manager_->LayoutWorkspaces();
 
   // ws1 is laied out in left most position.
   EXPECT_EQ(100, viewport()->bounds().width());
   EXPECT_EQ("0,0 100x100", ws1->bounds().ToString());
 
   // ws2 is laied out next to ws1, with 50 margin.
-  Workspace* ws2 = manager.CreateWorkspace();
-  manager.LayoutWorkspaces();
+  Workspace* ws2 = manager_->CreateWorkspace();
+  manager_->LayoutWorkspaces();
 
   EXPECT_EQ(250, viewport()->bounds().width());
   EXPECT_EQ("0,0 100x100", ws1->bounds().ToString());
   EXPECT_EQ("150,0 100x100", ws2->bounds().ToString());
 }
 
 TEST_F(WorkspaceManagerTest, WorkspaceManagerDragArea) {
   aura::Desktop::GetInstance()->screen()->set_work_area_insets(
       gfx::Insets(10, 10, 10, 10));
-
-  WorkspaceManager manager(viewport());
   viewport()->SetBounds(gfx::Rect(0, 0, 200, 200));
-  EXPECT_EQ("10,10 180x180", manager.GetDragAreaBounds().ToString());
+  EXPECT_EQ("10,10 180x180", manager_->GetDragAreaBounds().ToString());
 }
 
 TEST_F(WorkspaceManagerTest, Overview) {
-  WorkspaceManager manager(viewport());
-  manager.workspace_size_ = gfx::Size(500, 300);
+  manager_->workspace_size_ = gfx::Size(500, 300);
 
   // Creating two workspaces, ws1 which contains window w1,
   // and ws2 which contains window w2.
-  Workspace* ws1 = manager.CreateWorkspace();
+  Workspace* ws1 = manager_->CreateWorkspace();
   scoped_ptr<Window> w1(CreateTestWindow());
   viewport()->AddChild(w1.get());
   EXPECT_TRUE(ws1->AddWindowAfter(w1.get(), NULL));
 
-  Workspace* ws2 = manager.CreateWorkspace();
+  Workspace* ws2 = manager_->CreateWorkspace();
   scoped_ptr<Window> w2(CreateTestWindow());
   viewport()->AddChild(w2.get());
   EXPECT_TRUE(ws2->AddWindowAfter(w2.get(), NULL));
 
   // Activating a window switches the active workspace.
   w2->Activate();
-  EXPECT_EQ(ws2, manager.GetActiveWorkspace());
+  EXPECT_EQ(ws2, manager_->GetActiveWorkspace());
 
   // The size of viewport() is now ws1(500) + ws2(500) + margin(50).
   EXPECT_EQ("0,0 1050x300", viewport()->bounds().ToString());
-  EXPECT_FALSE(manager.is_overview());
-  manager.SetOverview(true);
-  EXPECT_TRUE(manager.is_overview());
+  EXPECT_FALSE(manager_->is_overview());
+  manager_->SetOverview(true);
+  EXPECT_TRUE(manager_->is_overview());
 
   // Switching overview mode doesn't change the active workspace.
-  EXPECT_EQ(ws2, manager.GetActiveWorkspace());
+  EXPECT_EQ(ws2, manager_->GetActiveWorkspace());
 
   // Activaing window w1 switches the active window and
   // the mode back to normal mode.
   w1->Activate();
-  EXPECT_EQ(ws1, manager.GetActiveWorkspace());
-  EXPECT_FALSE(manager.is_overview());
+  EXPECT_EQ(ws1, manager_->GetActiveWorkspace());
+  EXPECT_FALSE(manager_->is_overview());
 
   // Deleting w1 without DesktopDelegate resets the active workspace
   ws1->RemoveWindow(w1.get());
   delete ws1;
   w1.reset();
-  EXPECT_EQ(NULL, manager.GetActiveWorkspace());
-
+  EXPECT_EQ(NULL, manager_->GetActiveWorkspace());
   EXPECT_EQ("0,0 500x300", viewport()->bounds().ToString());
   ws2->RemoveWindow(w2.get());
   delete ws2;
   // The size of viewport() for no workspace case must be
   // same as one viewport() case.
   EXPECT_EQ("0,0 500x300", viewport()->bounds().ToString());
+
+  // Reset now before windows are destroyed.
+  manager_.reset();
 }
 
 TEST_F(WorkspaceManagerTest, WorkspaceManagerActivate) {
-  WorkspaceManager manager(viewport());
-  Workspace* ws1 = manager.CreateWorkspace();
-  Workspace* ws2 = manager.CreateWorkspace();
-  EXPECT_EQ(NULL, manager.GetActiveWorkspace());
+  Workspace* ws1 = manager_->CreateWorkspace();
+  Workspace* ws2 = manager_->CreateWorkspace();
+  EXPECT_EQ(NULL, manager_->GetActiveWorkspace());
 
   // Activate ws1.
   ws1->Activate();
-  EXPECT_EQ(ws1, manager.GetActiveWorkspace());
+  EXPECT_EQ(ws1, manager_->GetActiveWorkspace());
 
   // Activate ws2.
   ws2->Activate();
-  EXPECT_EQ(ws2, manager.GetActiveWorkspace());
+  EXPECT_EQ(ws2, manager_->GetActiveWorkspace());
 
   // Deleting active workspace sets active workspace to NULL.
   delete ws2;
-  EXPECT_EQ(NULL, manager.GetActiveWorkspace());
+  EXPECT_EQ(NULL, manager_->GetActiveWorkspace());
+  manager_.reset();
+}
+
+TEST_F(WorkspaceManagerTest, FindRotateWindow) {
+  manager_->workspace_size_ = 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-empt-145-w11-245-margin-265-365-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_->LayoutWorkspaces();
+  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();
+}
+
+TEST_F(WorkspaceManagerTest, RotateWindows) {
+  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(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()));
+
+  // 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()));
+
+  // 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()));
+
+  // 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()));
+
+  // Reset now before windows are destroyed.
+  manager_.reset();
 }
 
 class WorkspaceTest : public WorkspaceManagerTestBase {
 };
 
 TEST_F(WorkspaceTest, WorkspaceBasic) {
-  WorkspaceManager manager(viewport());
-
-  Workspace* ws = manager.CreateWorkspace();
+  Workspace* ws = manager_->CreateWorkspace();
   // Sanity check
   EXPECT_TRUE(ws->is_empty());
 
   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.
@@ skipping 19 matching lines @@
   // 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();
+}
+
+TEST_F(WorkspaceTest, RotateWindows) {
+  size_t orig_max = Workspace::SetMaxWindowsCount(3);
+  Workspace* ws = manager_->CreateWorkspace();
+  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);
+}
+
+TEST_F(WorkspaceTest, ShiftWindowsSingle) {
+  Workspace* ws = manager_->CreateWorkspace();
+  // Single window in a workspace case.
+  scoped_ptr<Window> w1(CreateTestWindow());
+  ws->AddWindowAfter(w1.get(), NULL);
+
+  scoped_ptr<Window> w2(CreateTestWindow());
+
+  // 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(),
+                       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(),
+                              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(),
+                              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(),
+                              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();
+}
+
+TEST_F(WorkspaceTest, ShiftWindowsMultiple) {
+  Workspace* ws = manager_->CreateWorkspace();
+  // Single window in a workspace case.
+  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(),
+                       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(),
+                            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(),
+                              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(),
+                              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()));
+
+  // Reset now before windows are destroyed.
+  manager_.reset();
 }
 
 }  // namespace aura_shell