Make mash register initial batch of accelerators in single shot.

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 535 matching lines @@
     AcceleratorControllerDelegate* delegate,
     ui::AcceleratorManagerDelegate* manager_delegate)
     : delegate_(delegate),
       accelerator_manager_(new ui::AcceleratorManager(manager_delegate)),
       accelerator_history_(new ui::AcceleratorHistory) {
   Init();
 }
 
 AcceleratorController::~AcceleratorController() {}
 
-void AcceleratorController::Register(const ui::Accelerator& accelerator,
-                                     ui::AcceleratorTarget* target) {
+void AcceleratorController::Register(
+    const std::vector<ui::Accelerator>& accelerators,
+    ui::AcceleratorTarget* target) {
   accelerator_manager_->Register(
-      accelerator, ui::AcceleratorManager::kNormalPriority, target);
+      accelerators, ui::AcceleratorManager::kNormalPriority, target);
 }
 
 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);
 }
@@ skipping 173 matching lines @@
                          kDeveloperAcceleratorDataLength);
     // Developer accelerators are also reserved.
     for (size_t i = 0; i < kDeveloperAcceleratorDataLength; ++i)
       reserved_actions_.insert(kDeveloperAcceleratorData[i].action);
   }
 }
 
 void AcceleratorController::RegisterAccelerators(
     const AcceleratorData accelerators[],
     size_t accelerators_length) {
+  std::vector<ui::Accelerator> ui_accelerators;
   for (size_t i = 0; i < accelerators_length; ++i) {
     ui::Accelerator accelerator =
         CreateAccelerator(accelerators[i].keycode, accelerators[i].modifiers,
                           accelerators[i].trigger_on_press);
-    Register(accelerator, this);
+    ui_accelerators.push_back(accelerator);
     accelerators_.insert(std::make_pair(accelerator, accelerators[i].action));
   }
+  Register(ui_accelerators, this);
 }
 
 void AcceleratorController::RegisterDeprecatedAccelerators() {
 #if defined(OS_CHROMEOS)
   for (size_t i = 0; i < kDeprecatedAcceleratorsDataLength; ++i) {
     const DeprecatedAcceleratorData* data = &kDeprecatedAcceleratorsData[i];
     actions_with_deprecations_[data->action] = data;
   }
 
+  std::vector<ui::Accelerator> ui_accelerators;
   for (size_t i = 0; i < kDeprecatedAcceleratorsLength; ++i) {
     const AcceleratorData& accelerator_data = kDeprecatedAccelerators[i];
     const ui::Accelerator deprecated_accelerator =
         CreateAccelerator(accelerator_data.keycode, accelerator_data.modifiers,
                           accelerator_data.trigger_on_press);
 
-    Register(deprecated_accelerator, this);
+    ui_accelerators.push_back(deprecated_accelerator);
     accelerators_[deprecated_accelerator] = accelerator_data.action;
     deprecated_accelerators_.insert(deprecated_accelerator);
   }
+  Register(ui_accelerators, this);
 #endif  // defined(OS_CHROMEOS)
 }
 
 bool AcceleratorController::CanPerformAction(
     AcceleratorAction action,
     const ui::Accelerator& accelerator) {
   if (accelerator.IsRepeat() && !repeatable_actions_.count(action))
     return false;
 
   AcceleratorProcessingRestriction restriction =
@@ skipping 379 matching lines @@
   if (wm_shell->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     wm_shell->accessibility_delegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
 }  // namespace ash