Separates out accelerator handling in windowmanager

ash/mus/window_manager.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/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "ash/common/shell_window_ids.h"
+#include "ash/mus/accelerators/accelerator_handler.h"
+#include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/bridge/wm_lookup_mus.h"
 #include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/frame/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/window_manager_observer.h"
 #include "ash/public/interfaces/container.mojom.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/mus_constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/app_list/presenter/app_list_presenter.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/mojo/event.mojom.h"
 #include "ui/views/mus/screen_mus.h"
 
 namespace ash {
 namespace mus {
 
-const uint32_t kWindowSwitchAccelerator = 1;
-
 void AssertTrue(bool success) {
   DCHECK(success);
 }
 
 // TODO(jamescook): Port ash::sysui::AppListPresenterMus and eliminate this.
 class AppListPresenterStub : public app_list::AppListPresenter {
  public:
   AppListPresenterStub() {}
   ~AppListPresenterStub() override {}
 
@@ skipping 21 matching lines @@
   // NOTE: |window_tree_client_| may already be null.
   delete window_tree_client_;
 }
 
 void WindowManager::Init(::ui::WindowTreeClient* window_tree_client) {
   DCHECK(!window_tree_client_);
   window_tree_client_ = window_tree_client;
 
   shadow_controller_.reset(new ShadowController(window_tree_client));
 
-  AddAccelerators();
-
   // The insets are roughly what is needed by CustomFrameView. The expectation
   // is at some point we'll write our own NonClientFrameView and get the insets
   // from it.
   ::ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ::ui::mojom::FrameDecorationValues::New();
   const gfx::Insets client_area_insets =
       NonClientFrameController::GetPreferredClientAreaInsets();
   frame_decoration_values->normal_client_area_insets = client_area_insets;
   frame_decoration_values->maximized_client_area_insets = client_area_insets;
   frame_decoration_values->max_title_bar_button_width =
@@ skipping 26 matching lines @@
   return root_window_controller->NewTopLevelWindow(properties);
 }
 
 std::set<RootWindowController*> WindowManager::GetRootWindowControllers() {
   std::set<RootWindowController*> result;
   for (auto& root_window_controller : root_window_controllers_)
     result.insert(root_window_controller.get());
   return result;
 }
 
+bool WindowManager::GetNextAcceleratorNamespaceId(uint16_t* id) {
+  if (accelerator_handlers_.size() == std::numeric_limits<uint16_t>::max())
+    return false;
+  while (accelerator_handlers_.count(next_accelerator_namespace_id_) > 0)
+    ++next_accelerator_namespace_id_;
+  *id = next_accelerator_namespace_id_;
+  ++next_accelerator_namespace_id_;
+  return true;
+}
+
+void WindowManager::AddAcceleratorHandler(uint16_t id_namespace,
+                                          AcceleratorHandler* handler) {
+  DCHECK_EQ(0u, accelerator_handlers_.count(id_namespace));
+  accelerator_handlers_[id_namespace] = handler;
+}
+
+void WindowManager::RemoveAcceleratorHandler(uint16_t id_namespace) {
+  accelerator_handlers_.erase(id_namespace);
+}
+
 void WindowManager::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void WindowManager::AddAccelerators() {
-  // TODO(sky): this is broke for multi-display case. Need to fix mus to
-  // deal correctly.
-  window_manager_client_->AddAccelerator(
-      kWindowSwitchAccelerator,
-      ::ui::CreateKeyMatcher(ui::mojom::KeyboardCode::TAB,
-                             ui::mojom::kEventFlagControlDown),
-      base::Bind(&AssertTrue));
-}
-
 RootWindowController* WindowManager::CreateRootWindowController(
     ::ui::Window* window,
     const display::Display& display) {
   // TODO(sky): there is timing issues with using ScreenMus.
   if (!screen_) {
     std::unique_ptr<views::ScreenMus> screen(new views::ScreenMus(nullptr));
     screen->Init(connector_);
     screen_ = std::move(screen);
   }
 
@@ skipping 123 matching lines @@
 
 void WindowManager::OnWmCancelMoveLoop(::ui::Window* window) {
   WmWindowMus* child_window = WmWindowMus::Get(window);
   MoveEventHandler* handler = MoveEventHandler::GetForWindow(child_window);
   if (handler)
     handler->RevertDrag();
 }
 
 ui::mojom::EventResult WindowManager::OnAccelerator(uint32_t id,
                                                     const ui::Event& event) {
-  switch (id) {
-    case kWindowSwitchAccelerator:
-      window_manager_client()->ActivateNextWindow();
-      break;
-    default:
-      FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                        OnAccelerator(id, event));
-      break;
-  }
+  auto iter = accelerator_handlers_.find(GetAcceleratorNamespaceId(id));
+  if (iter == accelerator_handlers_.end())
+    return ui::mojom::EventResult::HANDLED;
 
-  return ui::mojom::EventResult::HANDLED;
+  return iter->second->OnAccelerator(id, event);
 }
 
 }  // namespace mus
 }  // namespace ash