WindowManagerClient::AddAccelerator() should take an array

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/bridge/wm_window_mus.h"
 #include "ash/mus/window_manager.h"
 #include "base/logging.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/public/cpp/window_manager_delegate.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "ui/base/accelerators/accelerator_history.h"
 
+namespace {

[mfomitchev, 2016/11/24 19:56:13]

Just use the existing anonymous namespace in ash::mus below.

[thanhph, 2016/11/29 00:08:29]

I put this helper in different file accelerator_transport_util.h under namespace
ash::mus since it's used in unit test as well.

+
+struct AcceleratorTransportWrapper {
+  ui::mojom::AcceleratorTransportPtr accelerator_transport_ptr;
+  AcceleratorTransportWrapper(uint32_t id,
+                              ui::mojom::EventMatcherPtr event_matcher) {
+    accelerator_transport_ptr = ui::mojom::AcceleratorTransport::New();
+    accelerator_transport_ptr->id = id;
+    accelerator_transport_ptr->event_matcher = event_matcher.Clone();
+  }
+};
+}
+
 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();
@@ skipping 88 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()->AddAccelerator(
-      ComputeAcceleratorId(id_namespace_, ids.pre_id), std::move(event_matcher),
+  AcceleratorTransportWrapper pre_accelerator_transport_wrapper(

[mfomitchev, 2016/11/24 19:56:13]

I don't think this struct helps us much. Why not just create a method which
would return std::vector<ui::mojom::AcceleratorTransportPtr> (i.e. whatever you
need to pass to AddAccelerators())? 

[thanhph, 2016/11/29 00:08:29]

Done. Please review the accelerator_transport_util.cc.

+      ComputeAcceleratorId(id_namespace_, ids.pre_id),
+      std::move(event_matcher));
+
+  std::vector<ui::mojom::AcceleratorTransportPtr> pre_multi_accelerators;
+  pre_multi_accelerators.push_back(
+      std::move(pre_accelerator_transport_wrapper.accelerator_transport_ptr));
+
+  window_manager_->window_manager_client()->AddAccelerators(
+      std::move(pre_multi_accelerators),
       base::Bind(OnAcceleratorAdded, accelerator));
-  window_manager_->window_manager_client()->AddAccelerator(
+
+  AcceleratorTransportWrapper post_accelerator_transport_wrapper(
       ComputeAcceleratorId(id_namespace_, ids.post_id),
-      std::move(post_event_matcher),
+      std::move(post_event_matcher));
+
+  std::vector<ui::mojom::AcceleratorTransportPtr> post_multi_accelerators;
+  post_multi_accelerators.push_back(
+      std::move(post_accelerator_transport_wrapper.accelerator_transport_ptr));
+
+  window_manager_->window_manager_client()->AddAccelerators(
+      std::move(post_multi_accelerators),
       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);
@@ skipping 18 matching lines @@
   // 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