Eliminate OnConnect usage

services/ui/service.cc

 // Copyright 2014 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 "services/ui/service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 177 matching lines @@
   // happens either during OzonePlatform or PlatformEventSource initialization,
   // so keep this line below both of those.
   input_device_server_.RegisterAsObserver();
 
   window_server_.reset(new ws::WindowServer(this));
 
   ime_server_.Init(context()->connector(), test_config_);
 
   discardable_shared_memory_manager_ =
       base::MakeUnique<discardable_memory::DiscardableSharedMemoryManager>();
-}
 
-bool Service::OnConnect(const service_manager::ServiceInfo& remote_info,
-                        service_manager::InterfaceRegistry* registry) {
-  registry->AddInterface<mojom::AccessibilityManager>(this);
-  registry->AddInterface<mojom::Clipboard>(this);
-  registry->AddInterface<mojom::DisplayManager>(this);
-  registry->AddInterface<mojom::Gpu>(this);
-  registry->AddInterface<mojom::IMERegistrar>(this);
-  registry->AddInterface<mojom::IMEServer>(this);
-  registry->AddInterface<mojom::UserAccessManager>(this);
-  registry->AddInterface<mojom::UserActivityMonitor>(this);
-  registry->AddInterface<WindowTreeHostFactory>(this);
-  registry->AddInterface<mojom::WindowManagerWindowTreeFactory>(this);
-  registry->AddInterface<mojom::WindowTreeFactory>(this);
-  registry
-      ->AddInterface<discardable_memory::mojom::DiscardableSharedMemoryManager>(
+  registry_.AddInterface<mojom::AccessibilityManager>(this);
+  registry_.AddInterface<mojom::Clipboard>(this);
+  registry_.AddInterface<mojom::DisplayManager>(this);
+  registry_.AddInterface<mojom::Gpu>(this);
+  registry_.AddInterface<mojom::IMERegistrar>(this);
+  registry_.AddInterface<mojom::IMEServer>(this);
+  registry_.AddInterface<mojom::UserAccessManager>(this);
+  registry_.AddInterface<mojom::UserActivityMonitor>(this);
+  registry_.AddInterface<WindowTreeHostFactory>(this);
+  registry_.AddInterface<mojom::WindowManagerWindowTreeFactory>(this);
+  registry_.AddInterface<mojom::WindowTreeFactory>(this);
+  registry_
+      .AddInterface<discardable_memory::mojom::DiscardableSharedMemoryManager>(
           this);
   if (test_config_)
-    registry->AddInterface<WindowServerTest>(this);
+    registry_.AddInterface<WindowServerTest>(this);
 
   // On non-Linux platforms there will be no DeviceDataManager instance and no
   // purpose in adding the Mojo interface to connect to.
   if (input_device_server_.IsRegisteredAsObserver())
-    input_device_server_.AddInterface(registry);
+    input_device_server_.AddInterface(&registry_);
 
-  screen_manager_->AddInterfaces(registry);
+  screen_manager_->AddInterfaces(&registry_);
 
 #if defined(USE_OZONE)
-  ui::OzonePlatform::GetInstance()->AddInterfaces(registry);
+  ui::OzonePlatform::GetInstance()->AddInterfaces(&registry_);
 #endif
+}
 
-  return true;
+void Service::OnBindInterface(const service_manager::ServiceInfo& source_info,
+                              const std::string& interface_name,
+                              mojo::ScopedMessagePipeHandle interface_pipe) {
+  registry_.BindInterface(source_info.identity, interface_name,
+                          std::move(interface_pipe));
 }
 
 void Service::StartDisplayInit() {
   screen_manager_->Init(window_server_->display_manager());
 }
 
 void Service::OnFirstDisplayReady() {
   PendingRequests requests;
   requests.swap(pending_requests_);
   for (auto& request : requests) {
@@ skipping 124 matching lines @@
                      mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   mojo::MakeStrongBinding(
       base::MakeUnique<ws::WindowServerTestImpl>(window_server_.get()),
       std::move(request));
 }
 
 
 }  // namespace ui