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 541 matching lines @@
 }
 
 AcceleratorController::~AcceleratorController() {}
 
 void AcceleratorController::Register(const ui::Accelerator& accelerator,
                                      ui::AcceleratorTarget* target) {
   accelerator_manager_->Register(
       accelerator, ui::AcceleratorManager::kNormalPriority, target);
 }
 
+void AcceleratorController::Registers(
+    std::vector<ui::Accelerator>& ui_accelerators) {
+  accelerator_manager_->Registers(ui_accelerators);
+}
+
 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::Process(const ui::Accelerator& accelerator) {
@@ skipping 171 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);

[mfomitchev, 2016/12/20 03:10:26]

I am not sure what are you trying to do here. You are calling both Register()
and Registers() which doesn't make much sense. 

I wouldn't add Registers() at all, because I don't think it's going to help
much. I'd just call accelerator_manager_->Register() and pass it an array of
accelerators along with target and priority (this implies we either overload the
existing Register method in AcceleratorManager or rewrite it to always accept an
array). Note that the target and priority are all the same, so it might make
sense to take advantage of this: instead of passing an array of 3-element sets
{accelerator, priority, target}, you can pass an array of accelerators, plus the
target and the priority which these accelerators all share.

[thanhph, 2016/12/20 20:46:14]

Thanks. I go with the approach "pass an array of accelerators, plus the target
and the priority which these accelerators all share."

+    ui_accelerators.push_back(accelerator);
     accelerators_.insert(std::make_pair(accelerator, accelerators[i].action));
   }
+  Registers(ui_accelerators);
 }
 
 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;
   }
 
   for (size_t i = 0; i < kDeprecatedAcceleratorsLength; ++i) {
@@ skipping 398 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