Enable keyboard accelerators while a menu is open

ash/accelerators/accelerator_controller.cc

 // Copyright (c) 2012 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/accelerators/accelerator_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 
@@ skipping 702 matching lines @@
 void AcceleratorController::SetImeControlDelegate(
     scoped_ptr<ImeControlDelegate> ime_control_delegate) {
   ime_control_delegate_ = ime_control_delegate.Pass();
 }
 
 void AcceleratorController::SetScreenshotDelegate(
     scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
   screenshot_delegate_ = screenshot_delegate.Pass();
 }
 
+bool AcceleratorController::ShouldCloseMenuAndRepostAccelerator(
+    const ui::Accelerator& accelerator) const {
+  auto itr = accelerators_.find(accelerator);
+  if (itr == accelerators_.end())
+    return false;  // Menu shouldn't be closed for an invalid accelerator.
+
+  AcceleratorAction action = itr->second;
+  if (actions_keeping_menu_open_.count(action))

[pkotwicz, 2015/08/27 17:19:55]

How about:
return actions_keeping_menu_open_.count(action) == 0;

[afakhry, 2015/08/28 01:24:41]

Much better! Done. Thanks! :)

+    return false;
+
+  return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, ui::AcceleratorTarget implementation:
 
 bool AcceleratorController::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   std::map<ui::Accelerator, AcceleratorAction>::const_iterator it =
       accelerators_.find(accelerator);
   DCHECK(it != accelerators_.end());
   AcceleratorAction action = it->second;
   if (CanPerformAction(action, accelerator)) {
@@ skipping 24 matching lines @@
   for (size_t i = 0; i < kPreferredActionsLength; ++i)
     preferred_actions_.insert(kPreferredActions[i]);
   for (size_t i = 0; i < kReservedActionsLength; ++i)
     reserved_actions_.insert(kReservedActions[i]);
   for (size_t i = 0; i < kNonrepeatableActionsLength; ++i)
     nonrepeatable_actions_.insert(kNonrepeatableActions[i]);
   for (size_t i = 0; i < kActionsAllowedInAppModeLength; ++i)
     actions_allowed_in_app_mode_.insert(kActionsAllowedInAppMode[i]);
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i)
     actions_needing_window_.insert(kActionsNeedingWindow[i]);
+  for (size_t i = 0; i < kActionsKeepingMenuOpenLength; ++i)
+    actions_keeping_menu_open_.insert(kActionsKeepingMenuOpen[i]);
 
   RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
 
   if (debug::DebugAcceleratorsEnabled()) {
     RegisterAccelerators(kDebugAcceleratorData, kDebugAcceleratorDataLength);
     // All debug accelerators are reserved.
     for (size_t i = 0; i < kDebugAcceleratorDataLength; ++i)
       reserved_actions_.insert(kDebugAcceleratorData[i].action);
   }
 
@@ skipping 479 matching lines @@
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     scoped_ptr<KeyboardBrightnessControlDelegate>
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 }  // namespace ash