Make mash register initial batch of accelerators in single shot.

ash/mus/accelerators/accelerator_controller_registrar.cc

 // Copyright 2016 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/mus/accelerators/accelerator_controller_registrar.h"
 
 #include <limits>
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/accelerators/accelerator_router.h"
@@ skipping 10 matching lines @@
 namespace {
 
 // Callback from registering the accelerator.
 void OnAcceleratorAdded(const ui::Accelerator& accelerator, bool added) {
   // All our accelerators should be registered, so we expect |added| to be true.
   DCHECK(added) << "duplicate accelerator key_code=" << accelerator.key_code()
                 << " type=" << accelerator.type()
                 << " modifiers=" << accelerator.modifiers();
 }
 
+// Callback from registering the accelerators.
+void OnAcceleratorsAdded(const std::vector<ui::Accelerator>& ui_accelerators,
+                         bool added) {
+  for (auto iter = ui_accelerators.begin(); iter != ui_accelerators.end();
+       ++iter)
+    OnAcceleratorAdded(*iter, added);
 }  // namespace
+}
 
 AcceleratorControllerRegistrar::AcceleratorControllerRegistrar(
     WindowManager* window_manager,
     uint16_t id_namespace)
     : window_manager_(window_manager),
       id_namespace_(id_namespace),
       next_id_(0),
       router_(new AcceleratorRouter) {
   window_manager_->AddAcceleratorHandler(id_namespace, this);
 }
@@ skipping 75 matching lines @@
   DCHECK(accelerator.type() == ui::ET_KEY_PRESSED ||
          accelerator.type() == ui::ET_KEY_RELEASED);
   event_matcher->type_matcher->type = accelerator.type() == ui::ET_KEY_PRESSED
                                           ? ui::mojom::EventType::KEY_PRESSED
                                           : ui::mojom::EventType::KEY_RELEASED;
 
   ui::mojom::EventMatcherPtr post_event_matcher = event_matcher.Clone();
   post_event_matcher->accelerator_phase =
       ui::mojom::AcceleratorPhase::POST_TARGET;
 
-  window_manager_->window_manager_client()->AddAccelerators(
-      ui::CreateAcceleratorVector(
-          ComputeAcceleratorId(id_namespace_, ids.pre_id),
-          std::move(event_matcher)),
-      base::Bind(OnAcceleratorAdded, accelerator));
-
-  window_manager_->window_manager_client()->AddAccelerators(
-      ui::CreateAcceleratorVector(
-          ComputeAcceleratorId(id_namespace_, ids.post_id),
-          std::move(post_event_matcher)),
-      base::Bind(OnAcceleratorAdded, accelerator));
+  accelerator_ptrs_.push_back(

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

We can't completely repurpose this method to just be a helper method for
OnAcceleratorsRegistered - registering a single accelerator still needs to work
by itself, and right now it doesn't - we are just putting accelerator in the
array which doesn't get used until OnAcceleratorsRegistered is called.

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

Thanks, I added the window_manager_->window_manager_client()->AddAccelerators
back. The function void
AcceleratorControllerRegistrar::OnAcceleratorRegistered(const ui::Accelerator&
accelerator) now will require another argument bool add_accelerator_immediately
(default to true)

+      ui::CreateAccelerator(ComputeAcceleratorId(id_namespace_, ids.pre_id),
+                            std::move(event_matcher)));
+  accelerator_ptrs_.push_back(
+      ui::CreateAccelerator(ComputeAcceleratorId(id_namespace_, ids.post_id),
+                            std::move(post_event_matcher)));
 }
 
 void AcceleratorControllerRegistrar::OnAcceleratorUnregistered(
     const ui::Accelerator& accelerator) {
   auto iter = accelerator_to_ids_.find(accelerator);
   DCHECK(iter != accelerator_to_ids_.end());
   Ids ids = iter->second;
   accelerator_to_ids_.erase(iter);
   ids_.erase(ids.pre_id);
   ids_.erase(ids.post_id);
   DCHECK_EQ(accelerator_to_ids_.size() * 2, ids_.size());
   window_manager_->window_manager_client()->RemoveAccelerator(
       ComputeAcceleratorId(id_namespace_, ids.pre_id));
   window_manager_->window_manager_client()->RemoveAccelerator(
       ComputeAcceleratorId(id_namespace_, ids.post_id));
 }
 
+void AcceleratorControllerRegistrar::OnAcceleratorsRegistered(
+    std::vector<ui::Accelerator>& accelerators) {
+  accelerator_ptrs_.clear();
+  for (auto iter = accelerators.begin(); iter != accelerators.end(); ++iter)
+    OnAcceleratorRegistered(*iter);
+
+  window_manager_->window_manager_client()->AddAccelerators(
+      std::move(accelerator_ptrs_),
+      base::Bind(OnAcceleratorsAdded, accelerators));
+}
+
+void AcceleratorControllerRegistrar::OnAcceleratorsUnregistered(
+    std::vector<ui::Accelerator>& accelerators) {
+  for (auto iter = accelerators.begin(); iter != accelerators.end(); ++iter) {
+    OnAcceleratorUnregistered(*iter);
+  }
+}
+
 bool AcceleratorControllerRegistrar::GenerateIds(Ids* ids) {
   if (ids_.size() + 2 >= std::numeric_limits<uint16_t>::max())
     return false;
   ids->pre_id = GetNextLocalAcceleratorId();
   ids->post_id = GetNextLocalAcceleratorId();
   return true;
 }
 
 uint16_t AcceleratorControllerRegistrar::GetNextLocalAcceleratorId() {
   DCHECK_LT(ids_.size(), std::numeric_limits<uint16_t>::max());
   // Common case is we never wrap once, so this is typically cheap. Additionally
   // we expect there not to be too many accelerators.
   while (ids_.count(next_id_) > 0)
     ++next_id_;
   ids_.insert(next_id_);
   return next_id_++;
 }
 
 }  // namespace mus
 }  // namespace ash