Make Service own ServiceContext.

services/shell/service_manager.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/shell/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 395 matching lines @@
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     if (pid == base::kNullProcessId) {
       service_manager_->OnInstanceError(this);
       return;
     }
     pid_ = pid;
-    service_manager_->NotifyPIDAvailable(id_, pid_);
+    service_manager_->NotifyPIDAvailable(identity_, pid_);
   }
 
   void OnServiceLost(base::WeakPtr<shell::ServiceManager> service_manager) {
     service_.reset();
     OnConnectionLost(service_manager);
   }
 
   void OnConnectionLost(base::WeakPtr<shell::ServiceManager> service_manager) {
     // Any time a Connector is lost or we lose the Service connection, it
     // may have been the last pipe using this Instance. If so, clean up.
@@ skipping 160 matching lines @@
   Instance* instance = GetExistingInstance(CreateServiceManagerIdentity());
   DCHECK(instance);
   OnInstanceError(instance);
 }
 
 void ServiceManager::OnInstanceError(Instance* instance) {
   const Identity identity = instance->identity();
   // Remove the Service Manager.
   auto it = identity_to_instance_.find(identity);
   DCHECK(it != identity_to_instance_.end());
-  int id = instance->id();
   identity_to_instance_.erase(it);
-  listeners_.ForAllPtrs([this, id](mojom::ServiceManagerListener* listener) {
-                          listener->OnServiceStopped(id);
-                        });
+  listeners_.ForAllPtrs(
+      [this, identity](mojom::ServiceManagerListener* listener) {
+        listener->OnServiceStopped(mojom::Identity::From(identity));
+      });
   delete instance;
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params,
                              mojom::ServicePtr service) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ServiceManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
@@ skipping 31 matching lines @@
     for (auto entry : identity_to_instance_) {
       if (entry.first.name() == identity.name() &&
           entry.first.instance() == identity.instance()) {
         return entry.second;
       }
     }
   }
   return nullptr;
 }
 
-void ServiceManager::NotifyPIDAvailable(uint32_t id, base::ProcessId pid) {
-  listeners_.ForAllPtrs([id, pid](mojom::ServiceManagerListener* listener) {
-                          listener->OnServiceStarted(id, pid);
-                        });
+void ServiceManager::NotifyPIDAvailable(const Identity& identity,
+                                        base::ProcessId pid) {
+  listeners_.ForAllPtrs(
+      [identity, pid](mojom::ServiceManagerListener* listener) {
+        listener->OnServiceStarted(mojom::Identity::From(identity), pid);
+      });
 }
 
 bool ServiceManager::ConnectToExistingInstance(
     std::unique_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
   return !!instance && instance->ConnectToService(params);
 }
 
 ServiceManager::Instance* ServiceManager::CreateInstance(
     const Identity& source,
@@ skipping 131 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace shell