Move event handler to window_selector to ensure correct lifetime.

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/shell.h"
 #include "ash/wm/activation_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/overview/window_overview.h"
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "ash/wm/overview/window_selector_window.h"
 #include "base/auto_reset.h"
 #include "base/timer/timer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
+#include "ui/base/events/event.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 
 namespace {
 
 const int kOverviewDelayOnCycleMilliseconds = 300;
 
 // A comparator for locating a given target window.
 struct WindowSelectorWindowComparator
     : public std::unary_function<WindowSelectorWindow*, bool> {
   explicit WindowSelectorWindowComparator(const aura::Window* target_window)
       : target(target_window) {
   }
 
   bool operator()(const WindowSelectorWindow* window) const {
     return target == window->window();
   }
 
   const aura::Window* target;
 };
 
+// Filter to watch for the termination of a keyboard gesture to cycle through
+// multiple windows.
+class WindowSelectorEventFilter : public ui::EventHandler {
+ public:
+  WindowSelectorEventFilter(WindowSelector* selector);
+  virtual ~WindowSelectorEventFilter();
+
+  // Overridden from ui::EventHandler:
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+
+ private:
+  // A weak pointer to the WindowSelector which owns this instance.
+  WindowSelector* selector_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowSelectorEventFilter);
+};
+
+// Watch for all keyboard events by filtering the root window.
+WindowSelectorEventFilter::WindowSelectorEventFilter(WindowSelector* selector)
+    : selector_(selector) {
+  Shell::GetInstance()->AddPreTargetHandler(this);
+}
+
+WindowSelectorEventFilter::~WindowSelectorEventFilter() {
+  Shell::GetInstance()->RemovePreTargetHandler(this);
+}
+
+void WindowSelectorEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+  // Views uses VKEY_MENU for both left and right Alt keys.
+  if (event->key_code() == ui::VKEY_MENU &&
+      event->type() == ui::ET_KEY_RELEASED) {
+    selector_->SelectWindow();
+    // Warning: |this| will be deleted from here on.
+  }
+}
+
 }  // namespace
 
 WindowSelector::WindowSelector(const WindowList& windows,
                                WindowSelector::Mode mode,
                                WindowSelectorDelegate* delegate)
     : mode_(mode),
       start_overview_timer_(FROM_HERE,
           base::TimeDelta::FromMilliseconds(kOverviewDelayOnCycleMilliseconds),
           this, &WindowSelector::StartOverview),
       delegate_(delegate),
@@ skipping 15 matching lines @@
   Shell::GetInstance()->activation_client()->AddObserver(this);
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
       Shell::GetContainer(*iter,
                           kSwitchableWindowContainerIds[i])->AddObserver(this);
     }
   }
 
-  if (mode == WindowSelector::CYCLE)
+  if (mode == WindowSelector::CYCLE) {
+    event_handler_.reset(new WindowSelectorEventFilter(this));
     start_overview_timer_.Reset();
-  else
+  } else {
     StartOverview();
+  }
 }
 
 WindowSelector::~WindowSelector() {
   ResetFocusRestoreWindow(true);
   for (size_t i = 0; i < windows_.size(); i++) {
     windows_[i]->window()->RemoveObserver(this);
   }
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
@@ skipping 132 matching lines @@
   // If the window is in the windows_ list it needs to continue to be observed.
   if (std::find_if(windows_.begin(), windows_.end(),
           WindowSelectorWindowComparator(restore_focus_window_)) ==
               windows_.end()) {
     restore_focus_window_->RemoveObserver(this);
   }
   restore_focus_window_ = NULL;
 }
 
 }  // namespace ash