Added arrow key navigation to Overview Mode

ash/wm/overview/window_selector_unittest.cc

 // Copyright 2013 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/accessibility_delegate.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
@@ skipping 45 matching lines @@
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
         test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).shelf_view()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   aura::Window* CreateWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds);
   }
 
+  aura::Window* CreateWindowWithId(const gfx::Rect& bounds, int id) {
+    return CreateTestWindowInShellWithDelegate(&delegate_, id, bounds);
+  }
   aura::Window* CreateNonActivatableWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateWindow(bounds);
     aura::client::SetActivationDelegate(window,
                                         &non_activatable_activation_delegate_);
     EXPECT_FALSE(ash::wm::CanActivateWindow(window));
     return window;
   }
 
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
@@ skipping 53 matching lines @@
     transform.TransformRect(&bounds);
     return bounds;
   }
 
   void ClickWindow(aura::Window* window) {
     aura::test::EventGenerator event_generator(window->GetRootWindow(), window);
     gfx::RectF target = GetTransformedBounds(window);
     event_generator.ClickLeftButton();
   }
 
+  void SendKey(ui::KeyboardCode key) {
+      aura::test::EventGenerator event_generator(Shell::GetPrimaryRootWindow());
+      event_generator.PressKey(key, 0);
+      event_generator.ReleaseKey(key, 0);
+  }
+
   bool IsSelecting() {
     return ash::Shell::GetInstance()->window_selector_controller()->
         IsSelecting();
   }
 
   aura::Window* GetFocusedWindow() {
     return aura::client::GetFocusClient(
         Shell::GetPrimaryRootWindow())->GetFocusedWindow();
     }
 
-  ScopedVector<WindowSelectorItem>* GetWindowItems() {
-    return &(ash::Shell::GetInstance()->window_selector_controller()->
-        window_selector_->windows_);
+  const std::vector<WindowSelectorItem*>& GetWindowItemsForRoot(int index) {
+    return ash::Shell::GetInstance()->window_selector_controller()->
+        window_selector_->grid_list_[index]->window_list_.get();
     }
 
+  const aura::Window* GetSelectedWindow() {
+    WindowSelector* ws = ash::Shell::GetInstance()->
+        window_selector_controller()->window_selector_.get();
+    return ws->grid_list_[ws->selected_grid_index_]->
+        SelectedWindow()->SelectionWindow();
+  }
+
   views::Widget* GetLabelWidget(ash::WindowSelectorItem* window) {
     return window->window_label_.get();
   }
 
   test::ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
  private:
   aura::test::TestWindowDelegate delegate_;
@@ skipping 510 matching lines @@
   ASSERT_TRUE(IsSelecting());
   RunAllPendingInMessageLoop();
 }
 
 // Test that a label is created under the window on entering overview mode.
 TEST_F(WindowSelectorTest, CreateLabelUnderWindow) {
   scoped_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 100, 100)));
   base::string16 window_title = base::UTF8ToUTF16("My window");
   window->set_title(window_title);
   ToggleOverview();
-  WindowSelectorItem* window_item = GetWindowItems()->back();
+  WindowSelectorItem* window_item = GetWindowItemsForRoot(0).back();
   views::Widget* widget = GetLabelWidget(window_item);
   // Has the label widget been created?
   ASSERT_TRUE(widget);
   views::Label* label = static_cast<views::Label*>(widget->GetContentsView());
   // Verify the label matches the window title.
   EXPECT_EQ(label->text(), window_title);
   // Labels are located based on target_bounds, not the actual window item
   // bounds.
   gfx::Rect target_bounds(window_item->target_bounds());
   gfx::Rect expected_label_bounds(target_bounds.x(),
                                   target_bounds.bottom(),
                                   target_bounds.width(),
                                   label->GetPreferredSize().height());
   gfx::Rect real_label_bounds = widget->GetNativeWindow()->bounds();
   EXPECT_EQ(widget->GetNativeWindow()->bounds(), real_label_bounds);
 }
 
 // Tests that a label is created for the active panel in a group of panels in
 // overview mode.
 TEST_F(WindowSelectorTest, CreateLabelUnderPanel) {
   scoped_ptr<aura::Window> panel1(CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   scoped_ptr<aura::Window> panel2(CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   base::string16 panel1_title = base::UTF8ToUTF16("My panel");
   base::string16 panel2_title = base::UTF8ToUTF16("Another panel");
   panel1->set_title(panel1_title);
   panel2->set_title(panel2_title);
   wm::ActivateWindow(panel1.get());
   ToggleOverview();
-  WindowSelectorItem* window_item = GetWindowItems()->back();
+  WindowSelectorItem* window_item = GetWindowItemsForRoot(0).back();
   views::Widget* widget = GetLabelWidget(window_item);
   // Has the label widget been created?
   ASSERT_TRUE(widget);
   views::Label* label = static_cast<views::Label*>(widget->GetContentsView());
   // Verify the label matches the active window title.
   EXPECT_EQ(label->text(), panel1_title);
 }
 
 // Tests that overview updates the window positions if the display orientation
 // changes.
@@ skipping 21 matching lines @@
   // bounds.
   UpdateDisplay("600x200/r");
   EXPECT_EQ("0,0 200x600", root_window->bounds().ToString());
   for (ScopedVector<aura::Window>::iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
     EXPECT_TRUE(root_window->bounds().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(*iter))));
   }
 }
 
+// Tests traversing some windows in overview mode with the arrow keys in every
+// possible direction.
+TEST_F(WindowSelectorTest, BasicArrowKeyNavigation) {
+  if (!SupportsHostWindowResize())
+    return;
+  const size_t test_windows = 7;
+  UpdateDisplay("400x300");
+  ScopedVector<aura::Window> windows;
+  for (size_t i = test_windows; i > 0; i--)
+    windows.push_back(CreateWindowWithId(gfx::Rect(0, 0, 100, 100), i));
+
+  ui::KeyboardCode arrow_keys[] = {
+      ui::VKEY_RIGHT,
+      ui::VKEY_DOWN,
+      ui::VKEY_LEFT,
+      ui::VKEY_UP
+  };
+  // Expected window layout:
+  // +-------+  +-------+  +-------+
+  // |   1   |  |   2   |  |   3   |
+  // +-------+  +-------+  +-------+
+  // +-------+  +-------+  +-------+
+  // |   4   |  |   5   |  |   6   |
+  // +-------+  +-------+  +-------+
+  // +-------+
+  // |   7   |
+  // +-------+
+  // Index for each window during a full loop plus wrapping around.
+  int index_path_for_direction[][test_windows + 1] = {
+      {1, 2, 3, 4, 5, 6, 7, 1},  // Right
+      {1, 4, 7, 2, 5, 3, 6, 1},  // Down
+      {7, 6, 5, 4, 3, 2, 1, 7},  // Left
+      {6, 3, 5, 2, 7, 4, 1, 6}   // Up
+  };
+
+  for (size_t key_index = 0; key_index < arraysize(arrow_keys); key_index++) {
+    ToggleOverview();
+    for (size_t i = 0; i < test_windows + 1; i++) {
+      SendKey(arrow_keys[key_index]);
+      // TODO(nsatragno): Add a more readable error message by constructing a
+      // string from the window IDs.
+      EXPECT_EQ(GetSelectedWindow()->id(),
+                index_path_for_direction[key_index][i]);
+    }
+    ToggleOverview();
+  }
+}
+
+// Tests basic selection across multiple monitors.
+TEST_F(WindowSelectorTest, BasicMultiMonitorArrowKeyNavigation) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  UpdateDisplay("400x400,400x400");
+  gfx::Rect bounds1(0, 0, 100, 100);
+  gfx::Rect bounds2(450, 0, 100, 100);
+  scoped_ptr<aura::Window> window4(CreateWindow(bounds2));
+  scoped_ptr<aura::Window> window3(CreateWindow(bounds2));
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds1));
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds1));
+
+
+  ToggleOverview();
+
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window1.get());
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window2.get());
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window3.get());
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window4.get());
+}
+
 }  // namespace ash