Add frame-specific InterfaceProviderSpec.

content/common/service_manager/service_manager_connection_impl.cc

 // Copyright 2016 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 "content/common/service_manager/service_manager_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
@@ skipping 47 matching lines @@
       : pending_service_request_(std::move(service_request)),
         io_task_runner_(io_task_runner),
         io_thread_connector_(std::move(io_thread_connector)),
         pending_connector_request_(std::move(connector_request)),
         weak_factory_(this) {
     // This will be reattached by any of the IO thread functions on first call.
     io_thread_checker_.DetachFromThread();
   }
 
   // Safe to call from any thread.
-  void Start(const InitializeCallback& initialize_callback,
-             const ServiceFactoryCallback& create_service_callback,
-             const base::Closure& stop_callback) {
+  void Start(
+      const InitializeCallback& initialize_callback,
+      const ServiceManagerConnection::OnConnectHandler& on_connect_callback,
+      const ServiceFactoryCallback& create_service_callback,
+      const base::Closure& stop_callback) {
     DCHECK(!started_);
 
     started_ = true;
     callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     initialize_handler_ = initialize_callback;
+    on_connect_callback_ = on_connect_callback;
     create_service_callback_ = create_service_callback;
     stop_callback_ = stop_callback;
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&IOThreadContext::StartOnIOThread, this));
   }
 
   // Safe to call from whichever thread called Start() (or may have called
   // Start()). Must be called before IO thread shutdown.
   void ShutDown() {
     if (!started_)
@@ skipping 128 matching lines @@
     DCHECK(io_thread_checker_.CalledOnValidThread());
     has_browser_connection_ = false;
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // service_manager::Service implementation
 
   void OnStart(const service_manager::ServiceInfo& info) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     DCHECK(!initialize_handler_.is_null());
-    id_ = info.identity;
+    local_info_ = info;
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
-    callback_task_runner_->PostTask(FROM_HERE, base::Bind(handler, id_));
+    callback_task_runner_->PostTask(FROM_HERE,
+                                    base::Bind(handler, local_info_.identity));
   }
 
   bool OnConnect(const service_manager::ServiceInfo& remote_info,
                  service_manager::InterfaceRegistry* registry) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
+
+    callback_task_runner_->PostTask(
+        FROM_HERE, base::Bind(on_connect_callback_, local_info_, remote_info));
+
     std::string remote_service = remote_info.identity.name();
     if (remote_service == "service:service_manager") {
       // Only expose the ServiceFactory interface to the Service Manager.
       registry->AddInterface<service_manager::mojom::ServiceFactory>(this);
       return true;
     }
 
     bool accept = false;
     {
       base::AutoLock lock(lock_);
@@ skipping 62 matching lines @@
   std::unique_ptr<service_manager::Connector> io_thread_connector_;
   service_manager::mojom::ConnectorRequest pending_connector_request_;
 
   // TaskRunner on which to run our owner's callbacks, i.e. the ones passed to
   // Start().
   scoped_refptr<base::SequencedTaskRunner> callback_task_runner_;
 
   // Callback to run once Service::OnStart is invoked.
   InitializeCallback initialize_handler_;
 
+  // Callback to run when a connection request is received.
+  ServiceManagerConnection::OnConnectHandler on_connect_callback_;
+
   // Callback to run when a new Service request is received.
   ServiceFactoryCallback create_service_callback_;
 
   // Callback to run if the service is stopped by the service manager.
   base::Closure stop_callback_;
 
   // Called once a connection has been received from the browser process & the
   // default binder (below) has been set up.
   bool has_browser_connection_ = false;
 
-  service_manager::Identity id_;
+  service_manager::ServiceInfo local_info_;
 
   // Default binder callback used for the browser connection's
   // InterfaceRegistry.
   //
   // TODO(rockot): Remove this once all interfaces exposed to the browser are
   // exposed via a ConnectionFilter.
   service_manager::InterfaceRegistry::Binder default_browser_binder_;
 
   std::unique_ptr<service_manager::ServiceContext> service_context_;
   mojo::BindingSet<service_manager::mojom::ServiceFactory> factory_bindings_;
@@ skipping 71 matching lines @@
   context_->ShutDown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
 void ServiceManagerConnectionImpl::Start() {
   context_->Start(
       base::Bind(&ServiceManagerConnectionImpl::OnContextInitialized,
                  weak_factory_.GetWeakPtr()),
+      base::Bind(&ServiceManagerConnectionImpl::OnConnect,
+                 weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::CreateService,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceManagerConnectionImpl::SetInitializeHandler(
     const base::Closure& handler) {
   DCHECK(initialize_handler_.is_null());
   initialize_handler_ = handler;
@@ skipping 46 matching lines @@
   DCHECK(result.second);
 }
 
 void ServiceManagerConnectionImpl::AddServiceRequestHandler(
     const std::string& name,
     const ServiceRequestHandler& handler) {
   auto result = request_handlers_.insert(std::make_pair(name, handler));
   DCHECK(result.second);
 }
 
+int ServiceManagerConnectionImpl::AddOnConnectHandler(
+    const OnConnectHandler& handler) {
+  int id = ++next_on_connect_handler_id_;
+  on_connect_handlers_[id] = handler;
+  return id;
+}
+
+void ServiceManagerConnectionImpl::RemoveOnConnectHandler(int id) {
+  auto it = on_connect_handlers_.find(id);
+  DCHECK(it != on_connect_handlers_.end());
+  on_connect_handlers_.erase(it);
+}
+
 void ServiceManagerConnectionImpl::CreateService(
     service_manager::mojom::ServiceRequest request,
     const std::string& name) {
   auto it = request_handlers_.find(name);
   if (it != request_handlers_.end())
     it->second.Run(std::move(request));
 }
 
 void ServiceManagerConnectionImpl::OnContextInitialized(
     const service_manager::Identity& identity) {
   identity_ = identity;
   if (!initialize_handler_.is_null())
     base::ResetAndReturn(&initialize_handler_).Run();
 }
 
 void ServiceManagerConnectionImpl::OnConnectionLost() {
   if (!connection_lost_handler_.is_null())
     connection_lost_handler_.Run();
 }
 
+void ServiceManagerConnectionImpl::OnConnect(
+    const service_manager::ServiceInfo& local_info,
+    const service_manager::ServiceInfo& remote_info) {
+  local_info_ = local_info;
+  for (auto& handler : on_connect_handlers_)
+    handler.second.Run(local_info, remote_info);
+}
+
 void ServiceManagerConnectionImpl::GetInterface(
     service_manager::mojom::InterfaceProvider* provider,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content