Replace ServiceInfo with BindSourceInfo.

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 30 matching lines @@
 // A ref-counted object which owns the IO thread state of a
 // ServiceManagerConnectionImpl. This includes Service and ServiceFactory
 // bindings.
 class ServiceManagerConnectionImpl::IOThreadContext
     : public base::RefCountedThreadSafe<IOThreadContext>,
       public service_manager::Service,
       public service_manager::mojom::ServiceFactory,
       public mojom::Child {
  public:
   using InitializeCallback =
-      base::Callback<void(const service_manager::ServiceInfo&)>;
+      base::Callback<void(const service_manager::BindSourceInfo&)>;
 
   IOThreadContext(
       service_manager::mojom::ServiceRequest service_request,
       scoped_refptr<base::SequencedTaskRunner> io_task_runner,
       std::unique_ptr<service_manager::Connector> io_thread_connector,
       service_manager::mojom::ConnectorRequest connector_request)
       : 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)),
         child_binding_(this),
         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& local_info_available_callback,
-             const InitializeCallback& browser_info_available_callback,
+  void Start(const InitializeCallback& browser_info_available_callback,
              const base::Closure& stop_callback) {
     DCHECK(!started_);
 
     started_ = true;
     callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    local_info_available_callback_ = local_info_available_callback;
     browser_info_available_callback_ = browser_info_available_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 154 matching lines @@
       const std::string& name,
       const ServiceRequestHandler& handler) {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     auto result = request_handlers_.insert(std::make_pair(name, handler));
     DCHECK(result.second);
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // service_manager::Service implementation
 
-  void OnStart() override {
-    DCHECK(io_thread_checker_.CalledOnValidThread());
-    DCHECK(!local_info_available_callback_.is_null());
-    local_info_ = context()->local_info();
-
-    InitializeCallback handler =
-        base::ResetAndReturn(&local_info_available_callback_);
-    callback_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(handler, local_info_));
-  }
-
-  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+  void OnBindInterface(const service_manager::BindSourceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     if (source_info.identity.name() == service_manager::mojom::kServiceName &&
         interface_name == service_manager::mojom::ServiceFactory::Name_) {
       factory_bindings_.AddBinding(
           this, mojo::MakeRequest<service_manager::mojom::ServiceFactory>(
                     std::move(interface_pipe)));
     } else if (source_info.identity.name() == mojom::kBrowserServiceName &&
                interface_name == mojom::Child::Name_) {
@@ skipping 46 matching lines @@
   service_manager::mojom::ServiceRequest pending_service_request_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
   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 local_info_available_callback_;
   InitializeCallback browser_info_available_callback_;
 
   // Callback to run if the service is stopped by the service manager.
   base::Closure stop_callback_;
 
-  service_manager::ServiceInfo local_info_;
+  service_manager::BindSourceInfo local_info_;
 
   std::unique_ptr<service_manager::ServiceContext> service_context_;
   mojo::BindingSet<service_manager::mojom::ServiceFactory> factory_bindings_;
   int next_filter_id_ = kInvalidConnectionFilterId;
 
   // Not owned.
   MessageLoopObserver* message_loop_observer_ = nullptr;
 
   // Guards |connection_filters_|.
   base::Lock lock_;
@@ skipping 68 matching lines @@
 
 ServiceManagerConnectionImpl::~ServiceManagerConnectionImpl() {
   context_->ShutDown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
 void ServiceManagerConnectionImpl::Start() {
   context_->Start(
-      base::Bind(&ServiceManagerConnectionImpl::OnLocalServiceInfoAvailable,
-                 weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnBrowserServiceInfoAvailable,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
 
 service_manager::Connector* ServiceManagerConnectionImpl::GetConnector() {
   return connector_.get();
 }
 
-const service_manager::ServiceInfo& ServiceManagerConnectionImpl::GetLocalInfo()
-    const {
-  return local_info_;
-}
-
-const service_manager::ServiceInfo&
+const service_manager::BindSourceInfo&
 ServiceManagerConnectionImpl::GetBrowserInfo() const {
   return browser_info_;
 }
 
 void ServiceManagerConnectionImpl::SetConnectionLostClosure(
     const base::Closure& closure) {
   connection_lost_handler_ = closure;
 }
 
 int ServiceManagerConnectionImpl::AddConnectionFilter(
@@ skipping 22 matching lines @@
   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::OnLocalServiceInfoAvailable(
-    const service_manager::ServiceInfo& local_info) {
-  local_info_ = local_info;
-}
-
 void ServiceManagerConnectionImpl::OnBrowserServiceInfoAvailable(
-    const service_manager::ServiceInfo& browser_info) {
+    const service_manager::BindSourceInfo& browser_info) {
   browser_info_ = browser_info;
   for (auto& handler : on_connect_handlers_)
-    handler.second.Run(local_info_, browser_info_);
+    handler.second.Run(browser_info_);
 }
 
 void ServiceManagerConnectionImpl::OnConnectionLost() {
   if (!connection_lost_handler_.is_null())
     connection_lost_handler_.Run();
 }
 
 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