Adds kWillProcessAccelerator_KeyEventProperty

ash/common/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/common/accelerators/accelerator_controller.h"
 
 #include <utility>
 
 #include "ash/common/accelerators/accelerator_commands.h"
 #include "ash/common/accelerators/accelerator_controller_delegate.h"
@@ skipping 662 matching lines @@
 
 void AcceleratorController::Unregister(const ui::Accelerator& accelerator,
                                        ui::AcceleratorTarget* target) {
   accelerator_manager_->Unregister(accelerator, target);
 }
 
 void AcceleratorController::UnregisterAll(ui::AcceleratorTarget* target) {
   accelerator_manager_->UnregisterAll(target);
 }
 
+bool AcceleratorController::IsActionForAcceleratorEnabled(
+    const ui::Accelerator& accelerator) const {
+  std::map<ui::Accelerator, AcceleratorAction>::const_iterator it =
+      accelerators_.find(accelerator);
+  return it != accelerators_.end() && CanPerformAction(it->second, accelerator);
+}
+
 bool AcceleratorController::Process(const ui::Accelerator& accelerator) {
   return accelerator_manager_->Process(accelerator);
 }
 
 bool AcceleratorController::IsRegistered(
     const ui::Accelerator& accelerator) const {
   return accelerator_manager_->IsRegistered(accelerator);
 }
 
 bool AcceleratorController::IsPreferred(
@@ skipping 168 matching lines @@
 
     ui_accelerators.push_back(deprecated_accelerator);
     accelerators_[deprecated_accelerator] = accelerator_data.action;
     deprecated_accelerators_.insert(deprecated_accelerator);
   }
   Register(ui_accelerators, this);
 }
 
 bool AcceleratorController::CanPerformAction(
     AcceleratorAction action,
-    const ui::Accelerator& accelerator) {
+    const ui::Accelerator& accelerator) const {
   if (accelerator.IsRepeat() && !repeatable_actions_.count(action))
     return false;
 
   AcceleratorProcessingRestriction restriction =
       GetAcceleratorProcessingRestriction(action);
   if (restriction != RESTRICTION_NONE)
     return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 
   const ui::Accelerator& previous_accelerator =
       accelerator_history_->previous_accelerator();
@@ skipping 329 matching lines @@
   }
 }
 
 bool AcceleratorController::ShouldActionConsumeKeyEvent(
     AcceleratorAction action) {
   // Adding new exceptions is *STRONGLY* discouraged.
   return true;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
-AcceleratorController::GetAcceleratorProcessingRestriction(int action) {
+AcceleratorController::GetAcceleratorProcessingRestriction(int action) const {
   WmShell* wm_shell = WmShell::Get();
   if (wm_shell->IsPinned() &&
       actions_allowed_in_pinned_mode_.find(action) ==
           actions_allowed_in_pinned_mode_.end()) {
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   if (!Shell::Get()->session_controller()->IsActiveUserSessionStarted() &&
       actions_allowed_at_login_screen_.find(action) ==
           actions_allowed_at_login_screen_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
@@ skipping 58 matching lines @@
       data->uma_histogram_name, data->notification_message_id,
       data->old_shortcut_id, data->new_shortcut_id);
 
   if (!data->deprecated_enabled)
     return AcceleratorProcessingStatus::STOP;
 
   return AcceleratorProcessingStatus::PROCEED;
 }
 
 }  // namespace ash