mash: remove AcceleratorRegistrar.

ash/mus/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 "ash/mus/window_manager_application.h"
 
 #include <utility>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/mojo_interface_factory.h"
 #include "ash/common/wm_shell.h"
-#include "ash/mus/accelerators/accelerator_registrar_impl.h"
 #include "ash/mus/native_widget_factory_mus.h"
 #include "ash/mus/window_manager.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/tracing/public/cpp/provider.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/public/cpp/gpu_service.h"
 #include "services/ui/public/cpp/window.h"
@@ skipping 15 matching lines @@
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"  // nogncheck
 #endif
 
 namespace ash {
 namespace mus {
 
 WindowManagerApplication::WindowManagerApplication()
     : screenlock_state_listener_binding_(this) {}
 
 WindowManagerApplication::~WindowManagerApplication() {
-  // AcceleratorRegistrarImpl removes an observer in its destructor. Destroy
-  // it early on.
-  std::set<AcceleratorRegistrarImpl*> accelerator_registrars(
-      accelerator_registrars_);
-  for (AcceleratorRegistrarImpl* registrar : accelerator_registrars)
-    registrar->Destroy();
-
   // Destroy the WindowManager while still valid. This way we ensure
   // OnWillDestroyRootWindowController() is called (if it hasn't been already).
   window_manager_.reset();
 
   if (blocking_pool_) {
     // Like BrowserThreadImpl, the goal is to make it impossible for ash to
     // 'infinite loop' during shutdown, but to reasonably expect that all
     // BLOCKING_SHUTDOWN tasks queued during shutdown get run. There's nothing
     // particularly scientific about the number chosen.
     const int kMaxNewShutdownBlockingTasks = 1000;
     blocking_pool_->Shutdown(kMaxNewShutdownBlockingTasks);
   }
 
   gpu_service_.reset();
 #if defined(OS_CHROMEOS)
   statistics_provider_.reset();
 #endif
   ShutdownComponents();
 }
 
-void WindowManagerApplication::OnAcceleratorRegistrarDestroyed(
-    AcceleratorRegistrarImpl* registrar) {
-  accelerator_registrars_.erase(registrar);
-}
-
 void WindowManagerApplication::InitWindowManager(
     std::unique_ptr<ui::WindowTreeClient> window_tree_client,
     const scoped_refptr<base::SequencedWorkerPool>& blocking_pool) {
   InitializeComponents();
 #if defined(OS_CHROMEOS)
   // TODO(jamescook): Refactor StatisticsProvider so we can get just the data
   // we need in ash. Right now StatisticsProviderImpl launches the crossystem
   // binary to get system data, which we don't want to do twice on startup.
   statistics_provider_.reset(
       new chromeos::system::ScopedFakeStatisticsProvider());
@@ skipping 66 matching lines @@
   InitWindowManager(std::move(window_tree_client), blocking_pool_);
 }
 
 bool WindowManagerApplication::OnConnect(
     const service_manager::ServiceInfo& remote_info,
     service_manager::InterfaceRegistry* registry) {
   // Register services used in both classic ash and mash.
   mojo_interface_factory::RegisterInterfaces(
       registry, base::ThreadTaskRunnerHandle::Get());
 
-  registry->AddInterface<ui::mojom::AcceleratorRegistrar>(this);
   if (remote_info.identity.name() == "service:mash_session") {
     connector()->ConnectToInterface(remote_info.identity, &session_);
     session_->AddScreenlockStateListener(
         screenlock_state_listener_binding_.CreateInterfacePtrAndBind());
   }
   return true;
 }
 
-void WindowManagerApplication::Create(
-    const service_manager::Identity& remote_identity,
-    ui::mojom::AcceleratorRegistrarRequest request) {
-  if (!window_manager_->window_manager_client())
-    return;  // Can happen during shutdown.
-
-  uint16_t accelerator_namespace_id;
-  if (!window_manager_->GetNextAcceleratorNamespaceId(
-          &accelerator_namespace_id)) {
-    DVLOG(1) << "Max number of accelerators registered, ignoring request.";
-    // All ids are used. Normally shouldn't happen, so we close the connection.
-    return;
-  }
-  accelerator_registrars_.insert(new AcceleratorRegistrarImpl(
-      window_manager_.get(), accelerator_namespace_id, std::move(request),
-      base::Bind(&WindowManagerApplication::OnAcceleratorRegistrarDestroyed,
-                 base::Unretained(this))));
-}
-
 void WindowManagerApplication::ScreenlockStateChanged(bool locked) {
   window_manager_->SetScreenLocked(locked);
 }
 
 }  // namespace mus
 }  // namespace ash