Support global keyboard commands on Chrome OS.

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 839 matching lines @@
       accelerators_.find(remapped_accelerator);
   if (iter == accelerators_.end())
     return false;  // not an accelerator.
 
   return reserved_actions_.find(iter->second) != reserved_actions_.end();
 }
 
 bool AcceleratorController::PerformAction(int action,
                                           const ui::Accelerator& accelerator) {
   ash::Shell* shell = ash::Shell::GetInstance();
-  if (!shell->session_state_delegate()->IsActiveUserSessionStarted() &&
-      actions_allowed_at_login_screen_.find(action) ==
-      actions_allowed_at_login_screen_.end()) {
-    return false;
-  }
-  if (shell->session_state_delegate()->IsScreenLocked() &&
-      actions_allowed_at_lock_screen_.find(action) ==
-      actions_allowed_at_lock_screen_.end()) {
-    return false;
-  }
-  if (shell->IsSystemModalWindowOpen() &&
-      actions_allowed_at_modal_window_.find(action) ==
-      actions_allowed_at_modal_window_.end()) {
-    // Note: we return true. This indicates the shortcut is handled
-    // and will not be passed to the modal window. This is important
-    // for things like Alt+Tab that would cause an undesired effect
-    // in the modal window by cycling through its window elements.
-    return true;
-  }
-  if (shell->delegate()->IsRunningInForcedAppMode() &&
-      actions_allowed_in_app_mode_.find(action) ==
-      actions_allowed_in_app_mode_.end()) {
-    return false;
-  }
-  if (MruWindowTracker::BuildWindowList(false).empty() &&
-      actions_needing_window_.find(action) != actions_needing_window_.end()) {
-    Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
-        A11Y_ALERT_WINDOW_NEEDED);
-    return true;
-  }
+  AcceleratorProcessingRestriction restriction =
+      GetAcceleratorProcessingRestriction(action, accelerator);
+  if (restriction != RESTRICTION_NONE)
+    return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 
   const ui::KeyboardCode key_code = accelerator.key_code();
   // PerformAction() is performed from gesture controllers and passes
   // empty Accelerator() instance as the second argument. Such events
   // should never be suspended.
   const bool gesture_event = key_code == ui::VKEY_UNKNOWN;
   // Ignore accelerators invoked as repeated (while holding a key for a long
   // time, if their handling is nonrepeatable.
   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
       accelerator.IsRepeat() && !gesture_event) {
@@ skipping 233 matching lines @@
     case PRINT_VIEW_HIERARCHY:
       return HandlePrintViewHierarchy();
     case PRINT_WINDOW_HIERARCHY:
       return HandlePrintWindowHierarchy();
     default:
       NOTREACHED() << "Unhandled action " << action;
   }
   return false;
 }
 
+AcceleratorController::AcceleratorProcessingRestriction
+AcceleratorController::GetAcceleratorProcessingRestriction(
+    int action,
+    const ui::Accelerator& accelerator) {

[oshima, 2014/06/27 18:40:40]

accelerator is not used here. Maybe this is what you really want?

GetAcceleratorProcessingRestriction(const ui::Accelerator& accelerator) {
   std::map<ui::Accelerator, int>::const_iterator iter =
accelerators_.find(accelerator);
   int action = iter->second;
   ....

} 

[David Tseng, 2014/06/27 21:47:16]

I removed the accelerator parameter.

Perhaps the naming is unclear, but the function simply captures the scenarios in
which accelerators should not be processed or not propagated. (e.g. in login
screen).

+  ash::Shell* shell = ash::Shell::GetInstance();
+  if (!shell->session_state_delegate()->IsActiveUserSessionStarted() &&
+      actions_allowed_at_login_screen_.find(action) ==
+          actions_allowed_at_login_screen_.end()) {
+    return RESTRICTION_PREVENT_PROCESSING;
+  }
+  if (shell->session_state_delegate()->IsScreenLocked() &&
+      actions_allowed_at_lock_screen_.find(action) ==
+          actions_allowed_at_lock_screen_.end()) {
+    return RESTRICTION_PREVENT_PROCESSING;
+  }
+  if (shell->IsSystemModalWindowOpen() &&
+      actions_allowed_at_modal_window_.find(action) ==
+          actions_allowed_at_modal_window_.end()) {
+    // Note we prevent the shortcut from propagating so it will not
+    // be passed to the modal window. This is important for things like
+    // Alt+Tab that would cause an undesired effect in the modal window by
+    // cycling through its window elements.
+    return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
+  }
+  if (shell->delegate()->IsRunningInForcedAppMode() &&
+      actions_allowed_in_app_mode_.find(action) ==
+          actions_allowed_in_app_mode_.end()) {
+    return RESTRICTION_PREVENT_PROCESSING;
+  }
+  if (MruWindowTracker::BuildWindowList(false).empty() &&
+      actions_needing_window_.find(action) != actions_needing_window_.end()) {
+    Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
+        A11Y_ALERT_WINDOW_NEEDED);
+    return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
+  }
+  return RESTRICTION_NONE;
+}
+
 void AcceleratorController::SetBrightnessControlDelegate(
     scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
   brightness_control_delegate_ = brightness_control_delegate.Pass();
 }
 
 void AcceleratorController::SetImeControlDelegate(
     scoped_ptr<ImeControlDelegate> ime_control_delegate) {
   ime_control_delegate_ = ime_control_delegate.Pass();
 }
 
@@ skipping 32 matching lines @@
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace ash