Wires up registering accelerators from mash with the wm

ash/mus/accelerators/accelerator_registrar_impl.cc

 // Copyright 2015 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_registrar_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
+#include "ash/common/accelerators/accelerator_controller.h"
+#include "ash/common/wm_shell.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/window_manager.h"
 #include "base/bind.h"
 #include "services/ui/public/cpp/window_manager_delegate.h"
+#include "ui/events/event.h"
 
 namespace ash {
 namespace mus {
 
 namespace {
 
 void CallAddAcceleratorCallback(
     const ::ui::mojom::AcceleratorRegistrar::AddAcceleratorCallback& callback,
     bool result) {
   callback.Run(result);
 }
 
+// Returns true if |event_matcher| corresponds to matching an Accelerator.
+bool IsMatcherForKeyAccelerator(const ui::mojom::EventMatcher& event_matcher) {
+  return (
+      event_matcher.accelerator_phase ==
+          ui::mojom::AcceleratorPhase::PRE_TARGET &&
+      event_matcher.type_matcher &&
+      (event_matcher.type_matcher->type == ui::mojom::EventType::KEY_PRESSED ||
+       event_matcher.type_matcher->type ==
+           ui::mojom::EventType::KEY_RELEASED) &&
+      event_matcher.key_matcher && event_matcher.flags_matcher);
+}
+
+// Converts |event_matcher| into the ui::Accelerator it matches. Only valid if
+// IsMatcherForKeyAccelerator() returns true.
+ui::Accelerator EventMatcherToAccelerator(
+    const ui::mojom::EventMatcher& event_matcher) {
+  DCHECK(IsMatcherForKeyAccelerator(event_matcher));
+  ui::Accelerator accelerator(
+      static_cast<ui::KeyboardCode>(event_matcher.key_matcher->keyboard_code),
+      event_matcher.flags_matcher->flags);
+  accelerator.set_type(event_matcher.type_matcher->type ==
+                               ui::mojom::EventType::KEY_PRESSED
+                           ? ui::ET_KEY_PRESSED
+                           : ui::ET_KEY_RELEASED);
+  return accelerator;
+}
+
 }  // namespace
 
 AcceleratorRegistrarImpl::AcceleratorRegistrarImpl(
     WindowManager* window_manager,
     uint16_t accelerator_namespace,
     mojo::InterfaceRequest<AcceleratorRegistrar> request,
     const DestroyCallback& destroy_callback)
     : window_manager_(window_manager),
       binding_(this, std::move(request)),
       accelerator_namespace_(accelerator_namespace),
@@ skipping 25 matching lines @@
   window_manager_->RemoveAcceleratorHandler(accelerator_namespace_);
   window_manager_->RemoveObserver(this);
   RemoveAllAccelerators();
   destroy_callback_.Run(this);
 }
 
 void AcceleratorRegistrarImpl::OnBindingGone() {
   binding_.Unbind();
   // If there's no outstanding accelerators for this connection, then destroy
   // it.
-  if (accelerators_.empty())
+  if (accelerators_.empty() && keyboard_accelerator_to_id_.empty())
     delete this;
 }
 
 void AcceleratorRegistrarImpl::OnHandlerGone() {
   // The handler is dead. If AcceleratorRegistrar connection is also closed,
   // then destroy this. Otherwise, remove all the accelerators, but keep the
   // AcceleratorRegistrar connection alive (the client could still set another
   // handler and install new accelerators).
   if (!binding_.is_bound()) {
     delete this;
     return;
   }
   accelerator_handler_.reset();
   RemoveAllAccelerators();
 }
 
 void AcceleratorRegistrarImpl::RemoveAllAccelerators() {
   for (uint32_t accelerator : accelerators_)
     window_manager_->window_manager_client()->RemoveAccelerator(accelerator);
 
+  WmShell::Get()->accelerator_controller()->UnregisterAll(this);
+  keyboard_accelerator_to_id_.clear();
+  id_to_keyboard_accelerator_.clear();
+
   accelerators_.clear();
 }
 
+bool AcceleratorRegistrarImpl::AddAcceleratorForKeyBinding(
+    uint32_t accelerator_id,
+    const ::ui::mojom::EventMatcher& matcher,
+    const AddAcceleratorCallback& callback) {
+  if (!IsMatcherForKeyAccelerator(matcher))
+    return false;
+
+  const ui::Accelerator accelerator = EventMatcherToAccelerator(matcher);
+  if (keyboard_accelerator_to_id_.count(accelerator)) {
+    callback.Run(false);
+    return true;
+  }
+
+  AcceleratorController* accelerator_controller =
+      WmShell::Get()->accelerator_controller();
+  // TODO(sky): reenable this when we decide on the future of AppDriver.
+  // http://crbug.com/631836.
+  /*
+  if (accelerator_controller->IsRegistered(accelerator)) {
+    DVLOG(1) << "Attempt to register accelerator that is already registered";
+    callback.Run(false);
+    // Even though we're not registering the accelerator it's a key that should
+    // be handled as an accelerator, so return true.
+    return true;
+  }
+  */
+
+  const uint16_t local_id = GetAcceleratorLocalId(accelerator_id);
+  keyboard_accelerator_to_id_[accelerator] = local_id;
+  id_to_keyboard_accelerator_[local_id] = accelerator;
+  accelerator_controller->Register(accelerator, this);
+  callback.Run(true);
+  return true;
+}
+
 void AcceleratorRegistrarImpl::SetHandler(
     ::ui::mojom::AcceleratorHandlerPtr handler) {
   accelerator_handler_ = std::move(handler);
   accelerator_handler_.set_connection_error_handler(base::Bind(
       &AcceleratorRegistrarImpl::OnHandlerGone, base::Unretained(this)));
 }
 
 void AcceleratorRegistrarImpl::AddAccelerator(
     uint32_t accelerator_id,
     ::ui::mojom::EventMatcherPtr matcher,
     const AddAcceleratorCallback& callback) {
   if (!accelerator_handler_ || accelerator_id > 0xFFFF) {
     // The |accelerator_id| is too large, and it can't be handled correctly.
     callback.Run(false);
     DVLOG(1) << "AddAccelerator failed because of bogus id";
     return;
   }
+
   uint32_t namespaced_accelerator_id = ComputeAcceleratorId(
       accelerator_namespace_, static_cast<uint16_t>(accelerator_id));
+
+  if (accelerators_.count(namespaced_accelerator_id) ||
+      id_to_keyboard_accelerator_.count(
+          GetAcceleratorLocalId(namespaced_accelerator_id))) {
+    callback.Run(false);
+    DVLOG(1) << "AddAccelerator failed because id already in use "
+             << accelerator_id;
+    return;
+  }
+
+  if (AddAcceleratorForKeyBinding(accelerator_id, *matcher, callback))
+    return;
+
   accelerators_.insert(namespaced_accelerator_id);
   window_manager_->window_manager_client()->AddAccelerator(
       namespaced_accelerator_id, std::move(matcher),
       base::Bind(&CallAddAcceleratorCallback, callback));
 }
 
 void AcceleratorRegistrarImpl::RemoveAccelerator(uint32_t accelerator_id) {
   if (accelerator_id > 0xFFFF)
     return;
 
+  const uint16_t local_id = GetAcceleratorLocalId(accelerator_id);
+  auto iter = id_to_keyboard_accelerator_.find(local_id);
+  if (iter != id_to_keyboard_accelerator_.end()) {
+    WmShell::Get()->accelerator_controller()->Unregister(iter->second, this);
+    keyboard_accelerator_to_id_.erase(iter->second);
+    id_to_keyboard_accelerator_.erase(iter);
+    return;
+  }
+
   uint32_t namespaced_accelerator_id = ComputeAcceleratorId(
       accelerator_namespace_, static_cast<uint16_t>(accelerator_id));
   if (accelerators_.erase(namespaced_accelerator_id) == 0)
     return;
   window_manager_->window_manager_client()->RemoveAccelerator(
       namespaced_accelerator_id);
 
   // If the registrar is not bound anymore (i.e. the client can no longer
   // install new accelerators), and the last accelerator has been removed, then
   // there's no point keeping this alive anymore.
-  if (accelerators_.empty() && !binding_.is_bound())
+  if (accelerators_.empty() && keyboard_accelerator_to_id_.empty() &&
+      !binding_.is_bound()) {
     delete this;
+  }
 }
 
 ui::mojom::EventResult AcceleratorRegistrarImpl::OnAccelerator(
     uint32_t id,
     const ui::Event& event) {
   if (OwnsAccelerator(id))
     ProcessAccelerator(id, event);
   return ui::mojom::EventResult::HANDLED;
 }
 
 void AcceleratorRegistrarImpl::OnWindowTreeClientDestroyed() {
   delete this;
 }
 
+bool AcceleratorRegistrarImpl::AcceleratorPressed(
+    const ui::Accelerator& accelerator) {
+  auto iter = keyboard_accelerator_to_id_.find(accelerator);
+  DCHECK(iter != keyboard_accelerator_to_id_.end());
+  const ui::KeyEvent key_event(accelerator.type(), accelerator.key_code(),
+                               accelerator.modifiers());
+  // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
+  // mojom::Event directly to ui::Event.
+  accelerator_handler_->OnAccelerator(iter->second,
+                                      ui::Event::Clone(key_event));
+  return true;
+}
+
+bool AcceleratorRegistrarImpl::CanHandleAccelerators() const {
+  return true;
+}
+
 }  // namespace mus
 }  // namespace ash