Make mash register initial batch of accelerators in single shot.

ui/base/accelerators/accelerator_manager.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 "ui/base/accelerators/accelerator_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/base/accelerators/accelerator_manager_delegate.h"
 
 namespace ui {
 
 AcceleratorManager::AcceleratorManager(AcceleratorManagerDelegate* delegate)
     : delegate_(delegate) {}
 
 AcceleratorManager::~AcceleratorManager() {
 }
 
 void AcceleratorManager::Register(const Accelerator& accelerator,
                                   HandlerPriority priority,
                                   AcceleratorTarget* target) {
   DCHECK(target);
   AcceleratorTargetList& targets = accelerators_[accelerator].second;
   DCHECK(std::find(targets.begin(), targets.end(), target) == targets.end())
       << "Registering the same target multiple times";
-  const bool is_first_target_for_accelerator = targets.empty();
+  // const bool is_first_target_for_accelerator = targets.empty();
 
   // All priority accelerators go to the front of the line.
   if (priority == kHighPriority) {
     DCHECK(!accelerators_[accelerator].first)
         << "Only one high-priority handler can be registered";
     targets.push_front(target);
     // Mark that we have a priority accelerator at the front.
     accelerators_[accelerator].first = true;
   } else {
     // We are registering a normal priority handler. If no priority accelerator
     // handler has been registered before us, just add the new handler to the
     // front. Otherwise, register it after the first (only) priority handler.
     if (!accelerators_[accelerator].first)
       targets.push_front(target);
     else
       targets.insert(++targets.begin(), target);
   }
-  if (is_first_target_for_accelerator && delegate_)
-    delegate_->OnAcceleratorRegistered(accelerator);
+}
+
+void AcceleratorManager::Registers(std::vector<ui::Accelerator>& accelerators) {
+  if (delegate_)
+    delegate_->OnAcceleratorsRegistered(accelerators);
 }
 
 void AcceleratorManager::Unregister(const Accelerator& accelerator,
                                     AcceleratorTarget* target) {
   AcceleratorMap::iterator map_iter = accelerators_.find(accelerator);
   if (map_iter == accelerators_.end()) {
     NOTREACHED() << "Unregistering non-existing accelerator";
     return;
   }
 
@@ skipping 73 matching lines @@
   targets->remove(target);
   if (!targets->empty())
     return;
   const ui::Accelerator accelerator = map_iter->first;
   accelerators_.erase(map_iter);
   if (delegate_)
     delegate_->OnAcceleratorUnregistered(accelerator);
 }
 
 }  // namespace ui