Enable keyboard accelerators while a menu is open

ui/views/controls/menu/menu_event_filter.h

Index: ui/views/controls/menu/menu_event_filter.h
diff --git a/ui/views/controls/menu/menu_event_filter.h b/ui/views/controls/menu/menu_event_filter.h
new file mode 100644
index 0000000000000000000000000000000000000000..38a42c15f2e5d847fc1c18b13fc1df75be92856e
--- /dev/null
+++ b/ui/views/controls/menu/menu_event_filter.h
@@ -0,0 +1,85 @@
+// Copyright 2015 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.
+
+#ifndef UI_VIEWS_CONTROLS_MENU_MENU_EVENT_FILTER_H_
+#define UI_VIEWS_CONTROLS_MENU_MENU_EVENT_FILTER_H_
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/events/event_handler.h"
+#include "ui/views/views_export.h"
+
+namespace aura {
+class Window;
+}  // namespace aura
+
+namespace ui {
+class Accelerator;
+}  // namespace ui
+
+namespace views {
+
+class MenuController;
+
+// This will be used as a pre-target-handler whenever a menu is present. It is
+// needed to handle the interactions between accelerators and menus.
+class VIEWS_EXPORT MenuEventFilter : public ui::EventHandler {
+ public:
+  // Defines a delegate interface for the MenuEventFilter that can handle
+  // accelerators on its behalf.
+  class Delegate {
+   public:
+    enum Result {
+      RESULT_PROCESSED = 0,  // Accelerator was processed while menu is open.
+      RESULT_PROCESS_LATER,  // Accelerator should be processed after menu
+                             // closes.
+    };
+
+    Delegate() {}
+    virtual ~Delegate() {}
+
+    // When a KeyEvent is received, the corresponding |accelerator| must be
+    // stored in the |AcceleratorHistory| so that accelerator processing can
+    // be done properly.
+    virtual void StoreInHistory(const ui::Accelerator& accelerator) = 0;
+
+    // Processes the given |accelerator| and based on the action associated with
+    // it, it will either be processed now if the action is allowed while the
+    // menu remains open (and returns RESULT_PROCESSED), or if the action is
+    // not allowed to be performed while the menu is open then the accelerator
+    // should be skipped and be processed later (returns RESULT_PROCESS_LATER).
+    virtual Result ProcessAccelerator(const ui::Accelerator& accelerator) = 0;
+
+    // Processes the given |accelerator| immediately regardless of the action
+    // associated with it.
+    virtual void ProcessAcceleratorNow(const ui::Accelerator& accelerator) = 0;
+  };
+
+  MenuEventFilter();
+  ~MenuEventFilter() override;
+
+  static void SetMenuEventFilterDelegate(aura::Window* root_window,
+                                         MenuEventFilter::Delegate* delegate);
+  static MenuEventFilter::Delegate* GetMenuEventFilterDelegate(
+      aura::Window* root_window);
+
+  // ui::EventHandler:
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+
+  void SetDelegate(MenuEventFilter::Delegate* delegate);
+  void ClearDelegate();
+
+ private:
+  scoped_ptr<MenuEventFilter::Delegate> default_delegate_;
+  MenuEventFilter::Delegate* filter_delegate_;  // Not owned.
+
+  DISALLOW_COPY_AND_ASSIGN(MenuEventFilter);
+};
+
+}  // namespace views
+
+
+#endif  // UI_VIEWS_CONTROLS_MENU_MENU_EVENT_FILTER_H_