mus: Introduce AcceleratorRegistrar and AcceleratorHandler.

mash/wm/window_manager_application.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 "mash/wm/window_manager_application.h"
 
+#include "base/bind.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/event_matcher.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/cpp/window_tree_host_factory.h"
+#include "mash/wm/accelerator_registrar_impl.h"
 #include "mash/wm/background_layout.h"
 #include "mash/wm/shelf_layout.h"
 #include "mash/wm/window_layout.h"
 #include "mash/wm/window_manager_impl.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/services/tracing/public/cpp/tracing_impl.h"
 #include "ui/mojo/init/ui_init.h"
 #include "ui/views/mus/aura_init.h"
 #include "ui/views/mus/display_converter.h"
 
@@ skipping 22 matching lines @@
   return root_->GetChildById(id);
 }
 
 void WindowManagerApplication::AddAccelerators() {
   window_tree_host_->AddAccelerator(
       kWindowSwitchCmd,
       mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_TAB,
                             mus::mojom::EVENT_FLAGS_CONTROL_DOWN));
 }
 
+void WindowManagerApplication::OnAcceleratorRegistrarDestroyed(
+    AcceleratorRegistrarImpl* registrar) {
+  accelerator_registrars_.erase(registrar);
+}
+
 void WindowManagerApplication::Initialize(mojo::ApplicationImpl* app) {
   app_ = app;
   tracing_.Initialize(app);
   window_manager_.reset(new WindowManagerImpl());
   // Don't bind to the WindowManager immediately. Wait for OnEmbed() first.
   mus::mojom::WindowManagerPtr window_manager;
   requests_.push_back(new mojo::InterfaceRequest<mus::mojom::WindowManager>(
       mojo::GetProxy(&window_manager)));
   mus::mojom::WindowTreeHostClientPtr host_client;
   host_client_binding_.Bind(GetProxy(&host_client));
   mus::CreateSingleWindowTreeHost(app, host_client.Pass(), this,
                                   &window_tree_host_, window_manager.Pass(),
                                   window_manager_.get());
 }
 
 bool WindowManagerApplication::ConfigureIncomingConnection(
     mojo::ApplicationConnection* connection) {
-  connection->AddService(this);
+  connection->AddService<mus::mojom::AcceleratorRegistrar>(this);
+  connection->AddService<mus::mojom::WindowManager>(this);
   return true;
 }
 
 void WindowManagerApplication::OnAccelerator(uint32_t id,
                                              mus::mojom::EventPtr event) {
   switch (id) {
     case kWindowSwitchCmd:
       window_tree_host_->ActivateNextWindow();
       break;
     default:
-      NOTREACHED() << "Unknown accelerator command: " << id;
+      for (auto* registrar : accelerator_registrars_) {
+        if (registrar->OwnsAccelerator(id)) {
+          registrar->ProcessAccelerator(id, event.Pass());
+          break;
+        }
+      }
   }
 }
 
 void WindowManagerApplication::OnEmbed(mus::Window* root) {
   root_ = root;
   root_->AddObserver(this);
   CreateContainers();
   background_layout_.reset(new BackgroundLayout(
       GetWindowForContainer(mojom::CONTAINER_USER_BACKGROUND)));
   shelf_layout_.reset(
@@ skipping 16 matching lines @@
 }
 
 void WindowManagerApplication::OnConnectionLost(
     mus::WindowTreeConnection* connection) {
   // TODO(sky): shutdown.
   NOTIMPLEMENTED();
 }
 
 void WindowManagerApplication::Create(
     mojo::ApplicationConnection* connection,
+    mojo::InterfaceRequest<mus::mojom::AcceleratorRegistrar> request) {
+  static int accelerator_registrar_count = 0;
+  if (accelerator_registrar_count == std::numeric_limits<int>::max()) {
+    // Restart from zero if we have reached the limit. It is technically
+    // possible to end up with multiple active registrars with the same
+    // namespace, but it is highly unlikely. In the event that multiple
+    // registrars have the same namespace, this new registrar will be unable to
+    // install accelerators.

[Ben Goodger (Google), 2015/12/02 00:59:45]

how is this enforced? you don't seem to prevent registration.

[sadrul, 2015/12/02 19:14:25]

Ah, you are right. We do not actually do the right thing in
WindowTreeHostImpl/EventDispatcher when a dup accelerator is registered. I have
put up https://codereview.chromium.org/1487333004/, which we can use here to
notify the client when registering an accelerator fails.

However, I am not sure if this completely addresses this issue. For example,
some accelerators of the second client with the dup namespace can successfully
be registered, while attempting to register some others may fail (it depends on
what acceletators the first client had installed). I feel like that's a
reasonable expectation for the client, but I could be convinced otherwise. WDYT?

+    accelerator_registrar_count = 0;
+  }
+  accelerator_registrars_.insert(new AcceleratorRegistrarImpl(
+      window_tree_host_.get(), ++accelerator_registrar_count, request.Pass(),
+      base::Bind(&WindowManagerApplication::OnAcceleratorRegistrarDestroyed,
+                 base::Unretained(this))));
+}
+
+void WindowManagerApplication::Create(
+    mojo::ApplicationConnection* connection,
     mojo::InterfaceRequest<mus::mojom::WindowManager> request) {
   if (root_) {
     window_manager_binding_.AddBinding(window_manager_.get(), request.Pass());
   } else {
     requests_.push_back(
         new mojo::InterfaceRequest<mus::mojom::WindowManager>(request.Pass()));
   }
 }
 
 void WindowManagerApplication::OnWindowDestroyed(mus::Window* window) {
@@ skipping 13 matching lines @@
     DCHECK_EQ(mus::LoWord(window->id()), container)
         << "Containers must be created before other windows!";
     window->SetBounds(root_->bounds());
     window->SetVisible(true);
     root_->AddChild(window);
   }
 }
 
 }  // namespace wm
 }  // namespace mash