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"
 #include "ash/common/wm_shell.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/window_manager.h"
 #include "base/logging.h"
 #include "services/ui/common/accelerator_util.h"
 #include "ui/base/accelerators/accelerator_history.h"
 
 namespace ash {
 namespace mus {
 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 OnAcceleratorVectorAdded(const std::vector<ui::Accelerator>& accelerators,
+                              bool added) {
+  DCHECK(added) << "Unexpected accelerator vector registration failure.";

[mfomitchev, 2017/01/26 21:39:49]

Please add a comment similar to the one we had in OnAcceleratorAdded.

[thanhph1, 2017/01/26 22:24:05]

Done.

 }
 
 }  // namespace
 
 AcceleratorControllerRegistrar::AcceleratorControllerRegistrar(
     WindowManager* window_manager,
     uint16_t id_namespace)
     : window_manager_(window_manager),
       id_namespace_(id_namespace),
       next_id_(0),
@@ skipping 53 matching lines @@
                ? ui::mojom::EventResult::HANDLED
                : ui::mojom::EventResult::UNHANDLED;
   }
   DCHECK_EQ(GetAcceleratorLocalId(id), ids.post_id);
   // NOTE: for post return value doesn't really matter.
   return WmShell::Get()->accelerator_controller()->Process(accelerator)
              ? ui::mojom::EventResult::HANDLED
              : ui::mojom::EventResult::UNHANDLED;
 }
 
-void AcceleratorControllerRegistrar::OnAcceleratorRegistered(
+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::OnAcceleratorVectorRegistered(
+    const std::vector<ui::Accelerator>& accelerators) {
+  std::vector<ui::mojom::AcceleratorPtr> accelerator_vector;
+
+  for (auto iter = accelerators.begin(); iter != accelerators.end(); ++iter)
+    AddAcceleratorToVector(*iter, accelerator_vector);
+
+  window_manager_->window_manager_client()->AddAccelerators(
+      std::move(accelerator_vector),
+      base::Bind(OnAcceleratorVectorAdded, accelerators));
+}
+
+void AcceleratorControllerRegistrar::AddAcceleratorToVector(
+    const ui::Accelerator& accelerator,
+    std::vector<ui::mojom::AcceleratorPtr>& accelerator_vector) {
   Ids ids;
   if (!GenerateIds(&ids)) {
     DVLOG(1) << "max number of accelerators registered, dropping request";

[mfomitchev, 2017/01/26 21:39:49]

Let's turn this into LOG(ERROR) - this seems like a pretty bad failure, which we
should always log.

[thanhph1, 2017/01/26 22:24:05]

Done.

     return;
   }
   DCHECK_EQ(0u, accelerator_to_ids_.count(accelerator));
   accelerator_to_ids_[accelerator] = ids;
   DCHECK_EQ(accelerator_to_ids_.size() * 2, ids_.size());
 
-  ui::mojom::EventMatcherPtr event_matcher = ui::CreateKeyMatcher(
+  ui::mojom::EventMatcherPtr pre_event_matcher = ui::CreateKeyMatcher(
       static_cast<ui::mojom::KeyboardCode>(accelerator.key_code()),
       accelerator.modifiers());
-  event_matcher->accelerator_phase = ui::mojom::AcceleratorPhase::PRE_TARGET;
+  pre_event_matcher->accelerator_phase =
+      ui::mojom::AcceleratorPhase::PRE_TARGET;
   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;
+  pre_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();
+  ui::mojom::EventMatcherPtr post_event_matcher = pre_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));
+  accelerator_vector.push_back(
+      ui::CreateAccelerator(ComputeAcceleratorId(id_namespace_, ids.pre_id),
+                            std::move(pre_event_matcher)));
 
-  window_manager_->window_manager_client()->AddAccelerators(
-      ui::CreateAcceleratorVector(
-          ComputeAcceleratorId(id_namespace_, ids.post_id),
-          std::move(post_event_matcher)),
-      base::Bind(OnAcceleratorAdded, accelerator));
-}
-
-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));
+  accelerator_vector.push_back(
+      ui::CreateAccelerator(ComputeAcceleratorId(id_namespace_, ids.post_id),
+                            std::move(post_event_matcher)));
 }
 
 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