Added arrow key navigation to Overview Mode

ash/wm/overview/window_selector.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/wm/overview/window_selector.h"
 
 #include <algorithm>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/root_window_controller.h"
-#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/switchable_windows.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
+#include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/overview/window_selector_panels.h"
 #include "ash/wm/overview/window_selector_window.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
-#include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/background.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 
 namespace {
 
-// Conceptually the window overview is a table or grid of cells having this
-// fixed aspect ratio. The number of columns is determined by maximizing the
-// area of them based on the number of windows.
-const float kCardAspectRatio = 4.0f / 3.0f;
+// A comparator for locating a grid with a given root window.
+struct RootWindowGridComparator
+    : public std::unary_function<WindowGrid*, bool> {
+  explicit RootWindowGridComparator(const aura::Window* root_window)
+      : root_window_(root_window) {
+  }
 
-// The minimum number of cards along the major axis (i.e. horizontally on a
-// landscape orientation).
-const int kMinCardsMajor = 3;
+  bool operator()(WindowGrid* grid) const {
+    return (grid->root_window() == root_window_);
+  }
 
-// A comparator for locating a given target window.
+  const aura::Window* root_window_;
+};
+
+// A comparator for locating a WindowSelectorItem that contains a given target.

[flackr, 2014/06/03 17:12:07]

Why would using WindowSelectorItemTargetComparator not work? This seems to be
used for the gained active check, I think if any child of a selectable window
gains activation we should also exit and select that window.

[Nina, 2014/06/04 20:21:13]

Yes, this is more reasonable. We still use this comparator to determine the
WindowSelectorItem we are removing. This is OK, right? It would not make sense
to do anything if the child of an overview window is destroyed.

 struct WindowSelectorItemComparator
     : public std::unary_function<WindowSelectorItem*, bool> {
   explicit WindowSelectorItemComparator(const aura::Window* target_window)
       : target(target_window) {
   }
 
   bool operator()(WindowSelectorItem* window) const {
     return window->HasSelectableWindow(target);
   }
 
   const aura::Window* target;
 };
 
-// An observer which holds onto the passed widget until the animation is
-// complete.
-class CleanupWidgetAfterAnimationObserver : public ui::LayerAnimationObserver {
- public:
-  explicit CleanupWidgetAfterAnimationObserver(
-      scoped_ptr<views::Widget> widget);
-
-  // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) OVERRIDE;
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) OVERRIDE;
-  virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) OVERRIDE;
-
- private:
-  virtual ~CleanupWidgetAfterAnimationObserver();
-
-  scoped_ptr<views::Widget> widget_;
-
-  DISALLOW_COPY_AND_ASSIGN(CleanupWidgetAfterAnimationObserver);
-};
-
-CleanupWidgetAfterAnimationObserver::CleanupWidgetAfterAnimationObserver(
-    scoped_ptr<views::Widget> widget)
-    : widget_(widget.Pass()) {
-  widget_->GetNativeWindow()->layer()->GetAnimator()->AddObserver(this);
-}
-
-CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {
-  widget_->GetNativeWindow()->layer()->GetAnimator()->RemoveObserver(this);
-}
-
-void CleanupWidgetAfterAnimationObserver::OnLayerAnimationEnded(
-    ui::LayerAnimationSequence* sequence) {
-  delete this;
-}
-
-void CleanupWidgetAfterAnimationObserver::OnLayerAnimationAborted(
-    ui::LayerAnimationSequence* sequence) {
-  delete this;
-}
-
-void CleanupWidgetAfterAnimationObserver::OnLayerAnimationScheduled(
-    ui::LayerAnimationSequence* sequence) {
-}
-
 // A comparator for locating a selectable window given a targeted window.
 struct WindowSelectorItemTargetComparator
     : public std::unary_function<WindowSelectorItem*, bool> {
   explicit WindowSelectorItemTargetComparator(const aura::Window* target_window)
       : target(target_window) {
   }
 
   bool operator()(WindowSelectorItem* window) const {
     return window->Contains(target);
   }
@@ skipping 19 matching lines @@
 void UpdateShelfVisibility() {
   Shell::RootWindowControllerList root_window_controllers =
       Shell::GetInstance()->GetAllRootWindowControllers();
   for (Shell::RootWindowControllerList::iterator iter =
           root_window_controllers.begin();
        iter != root_window_controllers.end(); ++iter) {
     (*iter)->UpdateShelfVisibility();
   }
 }
 
+// Returns true if a window is contained in any of the windows passed on the
+// list.
+bool ContainedIn(const aura::Window* window,
+                 const std::vector<WindowSelectorItem*>& window_list) {

[flackr, 2014/06/03 17:12:07]

nit: Seems like you can use find_in with the WindowSelectorItemTargetComparator.

[Nina, 2014/06/04 20:21:13]

Done.

+  for (std::vector<WindowSelectorItem*>::const_iterator iter =
+      window_list.begin(); iter != window_list.end(); ++iter) {
+    if ((*iter)->Contains(window))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 WindowSelector::WindowSelector(const WindowList& windows,
                                WindowSelectorDelegate* delegate)
     : delegate_(delegate),
       restore_focus_window_(aura::client::GetFocusClient(
           Shell::GetPrimaryRootWindow())->GetFocusedWindow()),
-      ignore_activations_(false) {
+      ignore_activations_(false),
+      selected_grid_index_(0) {
   DCHECK(delegate_);
 
-  if (restore_focus_window_)
+  if (restore_focus_window_) {

[flackr, 2014/06/03 17:12:07]

nit: no curlies { } for single line block

[Nina, 2014/06/04 20:21:13]

Done.

     restore_focus_window_->AddObserver(this);
+  }
 
   std::vector<WindowSelectorPanels*> panels_items;
+  std::vector<WindowSelectorItem*> overview_items;
   for (size_t i = 0; i < windows.size(); ++i) {
     WindowSelectorItem* item = NULL;
     if (windows[i] != restore_focus_window_)
       windows[i]->AddObserver(this);
     observed_windows_.insert(windows[i]);
 
     if (windows[i]->type() == ui::wm::WINDOW_TYPE_PANEL &&
         wm::GetWindowState(windows[i])->panel_attached()) {
       // Attached panel windows are grouped into a single overview item per
       // root window (display).
       std::vector<WindowSelectorPanels*>::iterator iter =
           std::find_if(panels_items.begin(), panels_items.end(),
                        WindowSelectorItemForRoot(windows[i]->GetRootWindow()));
       WindowSelectorPanels* panels_item = NULL;
       if (iter == panels_items.end()) {
         panels_item = new WindowSelectorPanels();
         panels_items.push_back(panels_item);
-        windows_.push_back(panels_item);
+        overview_items.push_back(panels_item);
       } else {
         panels_item = *iter;
       }
       panels_item->AddWindow(windows[i]);
       item = panels_item;
     } else {
       item = new WindowSelectorWindow(windows[i]);
-      windows_.push_back(item);
+      overview_items.push_back(item);
     }
     // Verify that the window has been added to an item in overview.
     CHECK(item->Contains(windows[i]));
   }

[flackr, 2014/06/03 17:12:07]

All of this building the list of overview items could be more easily done as
part of constructing the windowgrid for a particular root window. Just pass in
the const WindowList& into the WindowGrid constructor.

Then we don't need to check for existing panel items on the current root since
we're building for one root window at a time and you can just remove the
grid_list_ if it ends up empty.

[Nina, 2014/06/04 20:21:13]

Done. I also moved the window removal code to the WindowGrid, now that it is
easier to handle like that.

-  UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", windows_.size());
+  DCHECK(!overview_items.empty());
+  UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", overview_items.size());
 
   // Observe window activations and switchable containers on all root windows
   // for newly created windows during overview.
   Shell::GetInstance()->activation_client()->AddObserver(this);
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
       aura::Window* container = Shell::GetContainer(*iter,
           kSwitchableWindowContainerIds[i]);
       container->AddObserver(this);
       observed_windows_.insert(container);
     }
   }
 
-  StartOverview();
+  // Remove focus from active window before entering overview.
+  aura::client::GetFocusClient(
+      Shell::GetPrimaryRootWindow())->FocusWindow(NULL);
+
+  Shell* shell = Shell::GetInstance();

[flackr, 2014/06/03 17:12:07]

Shell::GetInstance() is also used on 175, move before this too.

[Nina, 2014/06/04 20:21:13]

Done.

+  shell->OnOverviewModeStarting();

[flackr, 2014/06/03 17:12:07]

OnOverviewModeStarting should be sent before we start initializing overview,
i.e. as early as possible. At this point we've already removed focus, and
tracked the current state of all of the windows in overview.

[Nina, 2014/06/04 20:21:13]

Done.

+
+  for (WindowSelectorItemList::iterator iter = overview_items.begin();
+       iter != overview_items.end(); ++iter) {
+    (*iter)->PrepareForOverview();
+  }
+
+  // Build the window_grid list
+  aura::Window::Windows root_window_list = Shell::GetAllRootWindows();
+  for (size_t i = 0; i < root_window_list.size(); ++i) {
+    // Make sure the root window hosts at least one overview window.
+    if (std::find_if(overview_items.begin(), overview_items.end(),
+                     WindowSelectorItemForRoot(root_window_list[i])) !=
+                         overview_items.end()) {
+      grid_list_.push_back(new WindowGrid(root_window_list[i],
+                                          overview_items));
+    }
+  }
+  DCHECK(!grid_list_.empty());
+
+  shell->PrependPreTargetHandler(this);
+  shell->GetScreen()->AddObserver(this);
+  shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
+  HideAndTrackNonOverviewWindows(overview_items);
+  // Send an a11y alert.
+  shell->accessibility_delegate()->TriggerAccessibilityAlert(
+      A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
+
+  UpdateShelfVisibility();
 }
 
 WindowSelector::~WindowSelector() {
   ash::Shell* shell = ash::Shell::GetInstance();
 
   ResetFocusRestoreWindow(true);
   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
        iter != observed_windows_.end(); ++iter) {
     (*iter)->RemoveObserver(this);
   }
@@ skipping 17 matching lines @@
   shell->GetScreen()->RemoveObserver(this);
   UMA_HISTOGRAM_MEDIUM_TIMES(
       "Ash.WindowSelector.TimeInOverview",
       base::Time::Now() - overview_start_time_);
 
   // TODO(nsatragno): Change this to OnOverviewModeEnded and move it to when
   // everything is done.
   shell->OnOverviewModeEnding();
 
   // Clearing the window list resets the ignored_by_shelf flag on the windows.
-  windows_.clear();
+  grid_list_.clear();
   UpdateShelfVisibility();
 }
 
 void WindowSelector::CancelSelection() {
   delegate_->OnSelectionEnded();
 }
 
 void WindowSelector::OnKeyEvent(ui::KeyEvent* event) {
   if (event->type() != ui::ET_KEY_PRESSED)
     return;
 
-  if (event->key_code() == ui::VKEY_ESCAPE) {
-    CancelSelection();
+  bool handled = true;
+
+  switch (event->key_code()) {
+    case ui::VKEY_ESCAPE:
+      CancelSelection();
+      break;
+    case ui::VKEY_UP:
+      Move(WindowSelector::UP);
+      break;
+    case ui::VKEY_DOWN:
+      Move(WindowSelector::DOWN);
+      break;
+    case ui::VKEY_RIGHT:
+      Move(WindowSelector::RIGHT);
+      break;
+    case ui::VKEY_LEFT:
+      Move(WindowSelector::LEFT);
+      break;
+    case ui::VKEY_RETURN:
+      wm::GetWindowState(
+          grid_list_[selected_grid_index_]->
+              SelectedWindow()->SelectionWindow())->Activate();
+      break;
+    default:
+      // Not a key we are interested in.
+      handled = false;
+      break;
+  }
+  if (handled)
     event->SetHandled();
-  }
 }
 
 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 }
 
 void WindowSelector::OnDisplayRemoved(const gfx::Display& display) {
+  CancelSelection();

[flackr, 2014/06/03 17:12:07]

TODO(nsatragno): Keep window selection active on remaining display(s)?

[Nina, 2014/06/04 20:21:13]

This does sound like a good idea. Adding TODO.

 }
 
 void WindowSelector::OnDisplayMetricsChanged(const gfx::Display& display,
                                              uint32_t metrics) {
   PositionWindows(/* animate */ false);
 }
 
 void WindowSelector::OnWindowAdded(aura::Window* new_window) {
   if (new_window->type() != ui::wm::WINDOW_TYPE_NORMAL &&
       new_window->type() != ui::wm::WINDOW_TYPE_PANEL) {
     return;
   }
 
   for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
     if (new_window->parent()->id() == kSwitchableWindowContainerIds[i] &&
         !::wm::GetTransientParent(new_window)) {
       // The new window is in one of the switchable containers, abort overview.
       CancelSelection();
       return;
     }
   }
 }
 
 void WindowSelector::OnWindowDestroying(aura::Window* window) {
-  // window is one of a container, the restore_focus_window and/or
-  // one of the selectable windows in overview.
-  ScopedVector<WindowSelectorItem>::iterator iter =
-      std::find_if(windows_.begin(), windows_.end(),
-                   WindowSelectorItemComparator(window));
   window->RemoveObserver(this);
   observed_windows_.erase(window);
   if (window == restore_focus_window_)
     restore_focus_window_ = NULL;
-  if (iter == windows_.end())
+
+  // Find the grid corresponding to the window's root window.
+  ScopedVector<WindowGrid>::iterator grid_iter =
+      std::find_if(grid_list_.begin(), grid_list_.end(),
+                   RootWindowGridComparator(window->GetRootWindow()));
+
+  // If the a container or the |restore_focus_window_| are destroyed but not
+  // part of the overview, they will not be found in the grid list. Nothing
+  // else to do.
+  if (grid_iter == grid_list_.end())
     return;
 
-  (*iter)->RemoveWindow(window);
-  // If there are still windows in this selector entry then the overview is
-  // still active and the active selection remains the same.
-  if (!(*iter)->empty())
-    return;
+  (*grid_iter)->RemoveWindow(window);
 
-  windows_.erase(iter);
-  if (windows_.empty()) {
-    CancelSelection();
-    return;
+  if ((*grid_iter)->empty()) {
+    grid_list_.erase(grid_iter);
+    selected_grid_index_ = 0;

[flackr, 2014/06/03 17:12:07]

TODO, For more than 2 displays / grids the new selected grid index should be
based on the removed index.

[Nina, 2014/06/04 20:21:13]

Added TODO although this would not be a problem currently.

+    if (grid_list_.size() == 0)
+      CancelSelection();
   }
-  PositionWindows(true);
 }
 
 void WindowSelector::OnWindowBoundsChanged(aura::Window* window,

[flackr, 2014/06/03 17:12:07]

Bounds changed should really be handled in the WindowSelectorItem since the
WindowSelector and WindowGrid don't really need to do anything.

This could be a TODO.

[Nina, 2014/06/04 20:21:13]

This should be relatively easy to implement. Added TODO on header file.

                                            const gfx::Rect& old_bounds,
                                            const gfx::Rect& new_bounds) {
-  ScopedVector<WindowSelectorItem>::iterator iter =
-      std::find_if(windows_.begin(), windows_.end(),
+  ScopedVector<WindowGrid>::iterator grid =
+      std::find_if(grid_list_.begin(), grid_list_.end(),
+                   RootWindowGridComparator(window->GetRootWindow()));
+  if (grid == grid_list_.end())
+    return;
+  const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
+  ScopedVector<WindowSelectorItem>::const_iterator iter =
+      std::find_if(windows.begin(), windows.end(),
                    WindowSelectorItemTargetComparator(window));
-  if (iter == windows_.end())
+  if (iter == windows.end())
     return;
 
   // Immediately finish any active bounds animation.
   window->layer()->GetAnimator()->StopAnimatingProperty(
       ui::LayerAnimationElement::BOUNDS);
 
   // Recompute the transform for the window.
   (*iter)->RecomputeWindowTransforms();
 }
 
 void WindowSelector::OnWindowActivated(aura::Window* gained_active,
                                        aura::Window* lost_active) {
   if (ignore_activations_ || !gained_active)
     return;
 
-  ScopedVector<WindowSelectorItem>::iterator iter = std::find_if(
-      windows_.begin(), windows_.end(),
+  ScopedVector<WindowGrid>::iterator grid =
+      std::find_if(grid_list_.begin(), grid_list_.end(),
+                   RootWindowGridComparator(gained_active->GetRootWindow()));
+  if (grid == grid_list_.end())
+    return;
+  const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
+
+  ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
+      windows.begin(), windows.end(),
       WindowSelectorItemComparator(gained_active));
 
-  if (iter != windows_.end())
+  if (iter != windows.end())
     (*iter)->RestoreWindowOnExit(gained_active);
 
   // Don't restore focus on exit if a window was just activated.
   ResetFocusRestoreWindow(false);
   CancelSelection();
 }
 
 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
                                                  aura::Window* actual_active) {
   OnWindowActivated(request_active, actual_active);
 }
 
-void WindowSelector::StartOverview() {
-  // Remove focus from active window before entering overview.
-  aura::client::GetFocusClient(
-      Shell::GetPrimaryRootWindow())->FocusWindow(NULL);
-
-  Shell* shell = Shell::GetInstance();
-  shell->OnOverviewModeStarting();
-
-  for (WindowSelectorItemList::iterator iter = windows_.begin();
-       iter != windows_.end(); ++iter) {
-    (*iter)->PrepareForOverview();
-  }
-  PositionWindows(/* animate */ true);
-  DCHECK(!windows_.empty());
-  shell->PrependPreTargetHandler(this);
-  shell->GetScreen()->AddObserver(this);
-  shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
-  HideAndTrackNonOverviewWindows();
-  // Send an a11y alert.
-  shell->accessibility_delegate()->TriggerAccessibilityAlert(
-      A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
-
-  UpdateShelfVisibility();
-}
-
-bool WindowSelector::Contains(const aura::Window* window) {
-  for (WindowSelectorItemList::iterator iter = windows_.begin();
-      iter != windows_.end(); ++iter) {
-    if ((*iter)->Contains(window))
-      return true;
-  }
-  return false;
-}
-
 void WindowSelector::PositionWindows(bool animate) {
-  aura::Window::Windows root_window_list = Shell::GetAllRootWindows();
-  for (size_t i = 0; i < root_window_list.size(); ++i)
-    PositionWindowsFromRoot(root_window_list[i], animate);
-}
-
-void WindowSelector::PositionWindowsFromRoot(aura::Window* root_window,
-                                             bool animate) {
-  std::vector<WindowSelectorItem*> windows;
-  for (WindowSelectorItemList::iterator iter = windows_.begin();
-       iter != windows_.end(); ++iter) {
-    if ((*iter)->GetRootWindow() == root_window)
-      windows.push_back(*iter);
-  }
-
-  if (windows.empty())
-    return;
-
-  gfx::Size window_size;
-  gfx::Rect total_bounds = ScreenUtil::ConvertRectToScreen(
-      root_window,
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-          Shell::GetContainer(root_window, kShellWindowId_DefaultContainer)));
-
-  // Find the minimum number of windows per row that will fit all of the
-  // windows on screen.
-  size_t columns = std::max(
-      total_bounds.width() > total_bounds.height() ? kMinCardsMajor : 1,
-      static_cast<int>(ceil(sqrt(total_bounds.width() * windows.size() /
-                                 (kCardAspectRatio * total_bounds.height())))));
-  size_t rows = ((windows.size() + columns - 1) / columns);
-  window_size.set_width(std::min(
-      static_cast<int>(total_bounds.width() / columns),
-      static_cast<int>(total_bounds.height() * kCardAspectRatio / rows)));
-  window_size.set_height(window_size.width() / kCardAspectRatio);
-
-  // Calculate the X and Y offsets necessary to center the grid.
-  int x_offset = total_bounds.x() + ((windows.size() >= columns ? 0 :
-      (columns - windows.size()) * window_size.width()) +
-      (total_bounds.width() - columns * window_size.width())) / 2;
-  int y_offset = total_bounds.y() + (total_bounds.height() -
-      rows * window_size.height()) / 2;
-  for (size_t i = 0; i < windows.size(); ++i) {
-    gfx::Transform transform;
-    int column = i % columns;
-    int row = i / columns;
-    gfx::Rect target_bounds(window_size.width() * column + x_offset,
-                            window_size.height() * row + y_offset,
-                            window_size.width(),
-                            window_size.height());
-    windows[i]->SetBounds(root_window, target_bounds, animate);
+  for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
+      iter != grid_list_.end(); iter++) {
+    (*iter)->PositionWindows(animate);
   }
 }
 
-void WindowSelector::HideAndTrackNonOverviewWindows() {
+void WindowSelector::HideAndTrackNonOverviewWindows(
+    const std::vector<WindowSelectorItem*>& overview_items) {
   // Add the windows to hidden_windows first so that if any are destroyed
   // while hiding them they are tracked.
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator root_iter = root_windows.begin();
        root_iter != root_windows.end(); ++root_iter) {
     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
       aura::Window* container = Shell::GetContainer(*root_iter,
           kSwitchableWindowContainerIds[i]);
       for (aura::Window::Windows::const_iterator iter =
            container->children().begin(); iter != container->children().end();
            ++iter) {
-        if (Contains(*iter) || !(*iter)->IsVisible())
+        if (ContainedIn(*iter, overview_items) || !(*iter)->IsVisible())
           continue;
         hidden_windows_.Add(*iter);
       }
     }
   }
 
   // Copy the window list as it can change during iteration.
   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
   for (aura::WindowTracker::Windows::const_iterator iter =
        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
@@ skipping 22 matching lines @@
   }
   // If the window is in the observed_windows_ list it needs to continue to be
   // observed.
   if (observed_windows_.find(restore_focus_window_) ==
           observed_windows_.end()) {
     restore_focus_window_->RemoveObserver(this);
   }
   restore_focus_window_ = NULL;
 }
 
+void WindowSelector::Move(Direction direction) {
+  if (grid_list_[selected_grid_index_]->Move(direction)) {
+    // The grid reported that the movement command corresponds to the next
+    // root window, identify it and call Move() on it to initialize the
+    // selection widget.

[flackr, 2014/06/03 17:12:07]

TODO: If there are more than 2 monitors, move between grids in the requested
direction (i.e. up/left or right/down).

[Nina, 2014/06/04 20:21:13]

Added TODO. Again, this will not be a problem for now.

+    selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
+    grid_list_[selected_grid_index_]->Move(direction);
+  }
+}
+
 }  // namespace ash