ash/wm/overview/window_selector.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/wm/overview/window_selector.h"
   6
   7 #include <algorithm>
   8
   9 #include "ash/accessibility_delegate.h"
  10 #include "ash/ash_switches.h"
  11 #include "ash/metrics/user_metrics_recorder.h"
  12 #include "ash/root_window_controller.h"
  13 #include "ash/shell.h"
  14 #include "ash/shell_window_ids.h"
  15 #include "ash/switchable_windows.h"
  16 #include "ash/wm/overview/scoped_transform_overview_window.h"
  17 #include "ash/wm/overview/window_grid.h"
  18 #include "ash/wm/overview/window_selector_delegate.h"
  19 #include "ash/wm/overview/window_selector_item.h"
  20 #include "ash/wm/window_state.h"
  21 #include "base/auto_reset.h"
  22 #include "base/command_line.h"
  23 #include "base/metrics/histogram.h"
  24 #include "third_party/skia/include/core/SkPaint.h"
  25 #include "third_party/skia/include/core/SkPath.h"
  26 #include "ui/aura/client/focus_client.h"
  27 #include "ui/aura/window.h"
  28 #include "ui/aura/window_event_dispatcher.h"
  29 #include "ui/aura/window_observer.h"
  30 #include "ui/base/resource/resource_bundle.h"
  31 #include "ui/compositor/scoped_layer_animation_settings.h"
  32 #include "ui/events/event.h"
  33 #include "ui/gfx/canvas.h"
  34 #include "ui/gfx/screen.h"
  35 #include "ui/gfx/skia_util.h"
  36 #include "ui/views/border.h"
  37 #include "ui/views/controls/textfield/textfield.h"
  38 #include "ui/views/layout/box_layout.h"
  39 #include "ui/wm/core/window_util.h"
  40 #include "ui/wm/public/activation_client.h"
  41
  42 namespace ash {
  43
  44 namespace {
  45
  46 // The proportion of screen width that the text filter takes.
  47 const float kTextFilterScreenProportion = 0.25;
  48
  49 // The amount of padding surrounding the text in the text filtering textbox.
  50 const int kTextFilterHorizontalPadding = 8;
  51
  52 // The distance between the top of the screen and the top edge of the
  53 // text filtering textbox.
  54 const int kTextFilterDistanceFromTop = 32;
  55
  56 // The height of the text filtering textbox.
  57 const int kTextFilterHeight = 32;
  58
  59 // The font style used for text filtering.
  60 static const ::ui::ResourceBundle::FontStyle kTextFilterFontStyle =
  61     ::ui::ResourceBundle::FontStyle::MediumFont;
  62
  63 // The alpha value for the background of the text filtering textbox.
  64 const unsigned char kTextFilterOpacity = 180;
  65
  66 // The radius used for the rounded corners on the text filtering textbox.
  67 const int kTextFilterCornerRadius = 1;
  68
  69 // A comparator for locating a grid with a given root window.
  70 struct RootWindowGridComparator
  71     : public std::unary_function<WindowGrid*, bool> {
  72   explicit RootWindowGridComparator(const aura::Window* root_window)
  73       : root_window_(root_window) {
  74   }
  75
  76   bool operator()(WindowGrid* grid) const {
  77     return (grid->root_window() == root_window_);
  78   }
  79
  80   const aura::Window* root_window_;
  81 };
  82
  83 // A comparator for locating a selectable window given a targeted window.
  84 struct WindowSelectorItemTargetComparator
  85     : public std::unary_function<WindowSelectorItem*, bool> {
  86   explicit WindowSelectorItemTargetComparator(const aura::Window* target_window)
  87       : target(target_window) {
  88   }
  89
  90   bool operator()(WindowSelectorItem* window) const {
  91     return window->Contains(target);
  92   }
  93
  94   const aura::Window* target;
  95 };
  96
  97 // A comparator for locating a selector item for a given root.
  98 struct WindowSelectorItemForRoot
  99     : public std::unary_function<WindowSelectorItem*, bool> {
 100   explicit WindowSelectorItemForRoot(const aura::Window* root)
 101       : root_window(root) {
 102   }
 103
 104   bool operator()(WindowSelectorItem* item) const {
 105     return item->GetRootWindow() == root_window;
 106   }
 107
 108   const aura::Window* root_window;
 109 };
 110
 111 // A View having rounded corners and a specified background color which is
 112 // only painted within the bounds defined by the rounded corners.
 113 // TODO(tdanderson): This duplicates code from RoundedImageView. Refactor these
 114 //                   classes and move into ui/views.
 115 class RoundedContainerView : public views::View {
 116  public:
 117   RoundedContainerView(int corner_radius, SkColor background)
 118       : corner_radius_(corner_radius),
 119         background_(background) {
 120   }
 121
 122   virtual ~RoundedContainerView() {}
 123
 124   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
 125     views::View::OnPaint(canvas);
 126
 127     SkScalar radius = SkIntToScalar(corner_radius_);
 128     const SkScalar kRadius[8] = {radius, radius, radius, radius,
 129                                  radius, radius, radius, radius};
 130     SkPath path;
 131     gfx::Rect bounds(size());
 132     path.addRoundRect(gfx::RectToSkRect(bounds), kRadius);
 133
 134     SkPaint paint;
 135     paint.setAntiAlias(true);
 136     canvas->ClipPath(path, true);
 137     canvas->DrawColor(background_);
 138   }
 139
 140  private:
 141   int corner_radius_;
 142   SkColor background_;
 143
 144   DISALLOW_COPY_AND_ASSIGN(RoundedContainerView);
 145 };
 146
 147 // Triggers a shelf visibility update on all root window controllers.
 148 void UpdateShelfVisibility() {
 149   Shell::RootWindowControllerList root_window_controllers =
 150       Shell::GetInstance()->GetAllRootWindowControllers();
 151   for (Shell::RootWindowControllerList::iterator iter =
 152           root_window_controllers.begin();
 153        iter != root_window_controllers.end(); ++iter) {
 154     (*iter)->UpdateShelfVisibility();
 155   }
 156 }
 157
 158 // Initializes the text filter on the top of the main root window and requests
 159 // focus on its textfield.
 160 views::Widget* CreateTextFilter(views::TextfieldController* controller,
 161                                 aura::Window* root_window) {
 162   views::Widget* widget = new views::Widget;
 163   views::Widget::InitParams params;
 164   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
 165   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 166   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
 167   params.parent =
 168       Shell::GetContainer(root_window, ash::kShellWindowId_OverlayContainer);
 169   params.accept_events = true;
 170   params.bounds = gfx::Rect(
 171       root_window->bounds().width() / 2 * (1 - kTextFilterScreenProportion),
 172       kTextFilterDistanceFromTop,
 173       root_window->bounds().width() * kTextFilterScreenProportion,
 174       kTextFilterHeight);
 175   widget->Init(params);
 176
 177   // Use |container| to specify the padding surrounding the text and to give
 178   // the textfield rounded corners.
 179   views::View* container = new RoundedContainerView(
 180       kTextFilterCornerRadius, SkColorSetARGB(kTextFilterOpacity, 0, 0, 0));
 181   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
 182   int text_height = bundle.GetFontList(kTextFilterFontStyle).GetHeight();
 183   DCHECK(text_height);
 184   int vertical_padding = (kTextFilterHeight - text_height) / 2;
 185   container->SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical,
 186                                                    kTextFilterHorizontalPadding,
 187                                                    vertical_padding,
 188                                                    0));
 189
 190   views::Textfield* textfield = new views::Textfield;
 191   textfield->set_controller(controller);
 192   textfield->SetBackgroundColor(SK_ColorTRANSPARENT);
 193   textfield->SetBorder(views::Border::NullBorder());
 194   textfield->SetTextColor(SK_ColorWHITE);
 195   textfield->SetFontList(bundle.GetFontList(kTextFilterFontStyle));
 196
 197   container->AddChildView(textfield);
 198   widget->SetContentsView(container);
 199
 200   // The textfield initially contains no text, so shift its position to be
 201   // outside the visible bounds of the screen.
 202   gfx::Transform transform;
 203   transform.Translate(0, -WindowSelector::kTextFilterBottomEdge);
 204   widget->GetNativeWindow()->SetTransform(transform);
 205   widget->Show();
 206   textfield->RequestFocus();
 207
 208   return widget;
 209 }
 210
 211 }  // namespace
 212
 213 const int WindowSelector::kTextFilterBottomEdge =
 214     kTextFilterDistanceFromTop + kTextFilterHeight;
 215
 216 WindowSelector::WindowSelector(const WindowList& windows,
 217                                WindowSelectorDelegate* delegate)
 218     : delegate_(delegate),
 219       restore_focus_window_(aura::client::GetFocusClient(
 220           Shell::GetPrimaryRootWindow())->GetFocusedWindow()),
 221       ignore_activations_(false),
 222       selected_grid_index_(0),
 223       overview_start_time_(base::Time::Now()),
 224       num_key_presses_(0),
 225       num_items_(0),
 226       showing_selection_widget_(false),
 227       text_filter_string_length_(0),
 228       num_times_textfield_cleared_(0) {
 229   DCHECK(delegate_);
 230   Shell* shell = Shell::GetInstance();
 231   shell->OnOverviewModeStarting();
 232
 233   if (restore_focus_window_)
 234     restore_focus_window_->AddObserver(this);
 235
 236   const aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 237   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
 238        iter != root_windows.end(); iter++) {
 239     // Observed switchable containers for newly created windows on all root
 240     // windows.
 241     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 242       aura::Window* container = Shell::GetContainer(*iter,
 243           kSwitchableWindowContainerIds[i]);
 244       container->AddObserver(this);
 245       observed_windows_.insert(container);
 246     }
 247     scoped_ptr<WindowGrid> grid(new WindowGrid(*iter, windows, this));
 248     if (grid->empty())
 249       continue;
 250     num_items_ += grid->size();
 251     grid_list_.push_back(grid.release());
 252   }
 253
 254   // Do not call PrepareForOverview until all items are added to window_list_ as
 255   // we don't want to cause any window updates until all windows in overview
 256   // are observed. See http://crbug.com/384495.
 257   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 258        iter != grid_list_.end(); ++iter) {
 259     (*iter)->PrepareForOverview();
 260     (*iter)->PositionWindows(true);
 261   }
 262
 263   DCHECK(!grid_list_.empty());
 264   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 265
 266   text_filter_widget_.reset(
 267       CreateTextFilter(this, Shell::GetPrimaryRootWindow()));
 268
 269   shell->activation_client()->AddObserver(this);
 270
 271   shell->GetScreen()->AddObserver(this);
 272   shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
 273   HideAndTrackNonOverviewWindows();
 274   // Send an a11y alert.
 275   shell->accessibility_delegate()->TriggerAccessibilityAlert(
 276       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 277
 278   UpdateShelfVisibility();
 279 }
 280
 281 WindowSelector::~WindowSelector() {
 282   ash::Shell* shell = ash::Shell::GetInstance();
 283
 284   ResetFocusRestoreWindow(true);
 285   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
 286        iter != observed_windows_.end(); ++iter) {
 287     (*iter)->RemoveObserver(this);
 288   }
 289   shell->activation_client()->RemoveObserver(this);
 290   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 291
 292   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 293   for (aura::WindowTracker::Windows::const_iterator iter =
 294        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 295     ui::ScopedLayerAnimationSettings settings(
 296         (*iter)->layer()->GetAnimator());
 297     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 298         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 299     settings.SetPreemptionStrategy(
 300         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 301     (*iter)->layer()->SetOpacity(1);
 302     (*iter)->Show();
 303   }
 304
 305   shell->GetScreen()->RemoveObserver(this);
 306
 307   size_t remaining_items = 0;
 308   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 309       iter != grid_list_.end(); iter++) {
 310     remaining_items += (*iter)->size();
 311   }
 312
 313   DCHECK(num_items_ >= remaining_items);
 314   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems",
 315                            num_items_ - remaining_items);
 316   UMA_HISTOGRAM_MEDIUM_TIMES("Ash.WindowSelector.TimeInOverview",
 317                              base::Time::Now() - overview_start_time_);
 318
 319   // Record metrics related to text filtering.
 320   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringStringLength",
 321                            text_filter_string_length_);
 322   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringTextfieldCleared",
 323                            num_times_textfield_cleared_);
 324   if (text_filter_string_length_) {
 325     UMA_HISTOGRAM_MEDIUM_TIMES(
 326         "Ash.WindowSelector.TimeInOverviewWithTextFiltering",
 327         base::Time::Now() - overview_start_time_);
 328     UMA_HISTOGRAM_COUNTS_100(
 329         "Ash.WindowSelector.ItemsWhenTextFilteringUsed",
 330         remaining_items);
 331   }
 332
 333   // TODO(flackr): Change this to OnOverviewModeEnded and move it to when
 334   // everything is done.
 335   shell->OnOverviewModeEnding();
 336
 337   // Clearing the window list resets the ignored_by_shelf flag on the windows.
 338   grid_list_.clear();
 339   UpdateShelfVisibility();
 340 }
 341
 342 void WindowSelector::CancelSelection() {
 343   delegate_->OnSelectionEnded();
 344 }
 345
 346 void WindowSelector::OnGridEmpty(WindowGrid* grid) {
 347   ScopedVector<WindowGrid>::iterator iter =
 348       std::find(grid_list_.begin(), grid_list_.end(), grid);
 349   DCHECK(iter != grid_list_.end());
 350   grid_list_.erase(iter);
 351   // TODO(flackr): Use the previous index for more than two displays.
 352   selected_grid_index_ = 0;
 353   if (grid_list_.empty())
 354     CancelSelection();
 355 }
 356
 357 bool WindowSelector::HandleKeyEvent(views::Textfield* sender,
 358                                     const ui::KeyEvent& key_event) {
 359   if (key_event.type() != ui::ET_KEY_PRESSED)
 360     return false;
 361
 362   switch (key_event.key_code()) {
 363     case ui::VKEY_ESCAPE:
 364       CancelSelection();
 365       break;
 366     case ui::VKEY_UP:
 367       num_key_presses_++;
 368       Move(WindowSelector::UP, true);
 369       break;
 370     case ui::VKEY_DOWN:
 371       num_key_presses_++;
 372       Move(WindowSelector::DOWN, true);
 373       break;
 374     case ui::VKEY_RIGHT:
 375     case ui::VKEY_TAB:
 376       num_key_presses_++;
 377       Move(WindowSelector::RIGHT, true);
 378       break;
 379     case ui::VKEY_LEFT:
 380       num_key_presses_++;
 381       Move(WindowSelector::LEFT, true);
 382       break;
 383     case ui::VKEY_RETURN:
 384       // Ignore if no item is selected.
 385       if (!grid_list_[selected_grid_index_]->is_selecting())
 386         return false;
 387       UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses",
 388                                num_key_presses_);
 389       UMA_HISTOGRAM_CUSTOM_COUNTS(
 390           "Ash.WindowSelector.KeyPressesOverItemsRatio",
 391           (num_key_presses_ * 100) / num_items_, 1, 300, 30);
 392       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
 393           UMA_WINDOW_OVERVIEW_ENTER_KEY);
 394       wm::GetWindowState(grid_list_[selected_grid_index_]->
 395                          SelectedWindow()->SelectionWindow())->Activate();
 396       break;
 397     default:
 398       // Not a key we are interested in, allow the textfield to handle it.
 399       return false;
 400   }
 401   return true;
 402 }
 403
 404 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 405 }
 406
 407 void WindowSelector::OnDisplayRemoved(const gfx::Display& display) {
 408   // TODO(flackr): Keep window selection active on remaining displays.
 409   CancelSelection();
 410 }
 411
 412 void WindowSelector::OnDisplayMetricsChanged(const gfx::Display& display,
 413                                              uint32_t metrics) {
 414   PositionWindows(/* animate */ false);
 415 }
 416
 417 void WindowSelector::OnWindowAdded(aura::Window* new_window) {
 418   if (new_window->type() != ui::wm::WINDOW_TYPE_NORMAL &&
 419       new_window->type() != ui::wm::WINDOW_TYPE_PANEL) {
 420     return;
 421   }
 422
 423   for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 424     if (new_window->parent()->id() == kSwitchableWindowContainerIds[i] &&
 425         !::wm::GetTransientParent(new_window)) {
 426       // The new window is in one of the switchable containers, abort overview.
 427       CancelSelection();
 428       return;
 429     }
 430   }
 431 }
 432
 433 void WindowSelector::OnWindowDestroying(aura::Window* window) {
 434   window->RemoveObserver(this);
 435   observed_windows_.erase(window);
 436   if (window == restore_focus_window_)
 437     restore_focus_window_ = NULL;
 438 }
 439
 440 void WindowSelector::OnWindowActivated(aura::Window* gained_active,
 441                                        aura::Window* lost_active) {
 442   if (ignore_activations_ ||
 443       !gained_active ||
 444       gained_active == text_filter_widget_->GetNativeWindow()) {
 445     return;
 446   }
 447
 448   ScopedVector<WindowGrid>::iterator grid =
 449       std::find_if(grid_list_.begin(), grid_list_.end(),
 450                    RootWindowGridComparator(gained_active->GetRootWindow()));
 451   if (grid == grid_list_.end())
 452     return;
 453   const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
 454
 455   ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
 456       windows.begin(), windows.end(),
 457       WindowSelectorItemTargetComparator(gained_active));
 458
 459   if (iter != windows.end())
 460     (*iter)->RestoreWindowOnExit(gained_active);
 461
 462   // Don't restore focus on exit if a window was just activated.
 463   ResetFocusRestoreWindow(false);
 464   CancelSelection();
 465 }
 466
 467 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
 468                                                  aura::Window* actual_active) {
 469   OnWindowActivated(request_active, actual_active);
 470 }
 471
 472 void WindowSelector::ContentsChanged(views::Textfield* sender,
 473                                      const base::string16& new_contents) {
 474   if (CommandLine::ForCurrentProcess()->HasSwitch(
 475       switches::kAshDisableTextFilteringInOverviewMode)) {
 476     return;
 477   }
 478
 479   text_filter_string_length_ = new_contents.length();
 480   if (!text_filter_string_length_)
 481     num_times_textfield_cleared_++;
 482
 483   bool should_show_selection_widget = !new_contents.empty();
 484   if (showing_selection_widget_ != should_show_selection_widget) {
 485     ui::ScopedLayerAnimationSettings animation_settings(
 486         text_filter_widget_->GetNativeWindow()->layer()->GetAnimator());
 487     animation_settings.SetPreemptionStrategy(
 488         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 489     animation_settings.SetTweenType(showing_selection_widget_ ?
 490         gfx::Tween::FAST_OUT_LINEAR_IN : gfx::Tween::LINEAR_OUT_SLOW_IN);
 491
 492     gfx::Transform transform;
 493     if (should_show_selection_widget) {
 494       transform.Translate(0, 0);
 495       text_filter_widget_->GetNativeWindow()->layer()->SetOpacity(1);
 496     } else {
 497       transform.Translate(0, -kTextFilterBottomEdge);
 498       text_filter_widget_->GetNativeWindow()->layer()->SetOpacity(0);
 499     }
 500
 501     text_filter_widget_->GetNativeWindow()->SetTransform(transform);
 502     showing_selection_widget_ = should_show_selection_widget;
 503   }
 504   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 505        iter != grid_list_.end(); iter++) {
 506     (*iter)->FilterItems(new_contents);
 507   }
 508
 509   // If the selection widget is not active, execute a Move() command so that it
 510   // shows up on the first undimmed item.
 511   if (grid_list_[selected_grid_index_]->is_selecting())
 512     return;
 513   Move(WindowSelector::RIGHT, false);
 514 }
 515
 516 void WindowSelector::PositionWindows(bool animate) {
 517   for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
 518       iter != grid_list_.end(); iter++) {
 519     (*iter)->PositionWindows(animate);
 520   }
 521 }
 522
 523 void WindowSelector::HideAndTrackNonOverviewWindows() {
 524   // Add the windows to hidden_windows first so that if any are destroyed
 525   // while hiding them they are tracked.
 526   for (ScopedVector<WindowGrid>::iterator grid_iter = grid_list_.begin();
 527       grid_iter != grid_list_.end(); ++grid_iter) {
 528     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
 529       const aura::Window* container =
 530           Shell::GetContainer((*grid_iter)->root_window(),
 531                               kSwitchableWindowContainerIds[i]);
 532       for (aura::Window::Windows::const_iterator iter =
 533            container->children().begin(); iter != container->children().end();
 534            ++iter) {
 535         if (!(*iter)->IsVisible() || (*grid_iter)->Contains(*iter))
 536           continue;
 537         hidden_windows_.Add(*iter);
 538       }
 539     }
 540   }
 541
 542   // Copy the window list as it can change during iteration.
 543   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
 544   for (aura::WindowTracker::Windows::const_iterator iter =
 545        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
 546     if (!hidden_windows_.Contains(*iter))
 547       continue;
 548     ui::ScopedLayerAnimationSettings settings(
 549         (*iter)->layer()->GetAnimator());
 550     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 551         ScopedTransformOverviewWindow::kTransitionMilliseconds));
 552     settings.SetPreemptionStrategy(
 553         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 554     (*iter)->Hide();
 555     // Hiding the window can result in it being destroyed.
 556     if (!hidden_windows_.Contains(*iter))
 557       continue;
 558     (*iter)->layer()->SetOpacity(0);
 559   }
 560 }
 561
 562 void WindowSelector::ResetFocusRestoreWindow(bool focus) {
 563   if (!restore_focus_window_)
 564     return;
 565   if (focus) {
 566     base::AutoReset<bool> restoring_focus(&ignore_activations_, true);
 567     restore_focus_window_->Focus();
 568   }
 569   // If the window is in the observed_windows_ list it needs to continue to be
 570   // observed.
 571   if (observed_windows_.find(restore_focus_window_) ==
 572           observed_windows_.end()) {
 573     restore_focus_window_->RemoveObserver(this);
 574   }
 575   restore_focus_window_ = NULL;
 576 }
 577
 578 void WindowSelector::Move(Direction direction, bool animate) {
 579   // Keep calling Move() on the grids until one of them reports no overflow or
 580   // we made a full cycle on all the grids.
 581   for (size_t i = 0;
 582       i <= grid_list_.size() &&
 583       grid_list_[selected_grid_index_]->Move(direction, animate); i++) {
 584     // TODO(flackr): If there are more than two monitors, move between grids
 585     // in the requested direction.
 586     selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
 587   }
 588 }
 589
 590 }  // namespace ash