Cancel ServiceManager connection requests if source Instance dies

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 263 matching lines @@
     if (!ValidateCapabilities(target, callback))
       return;
 
     std::unique_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(identity_);
     params->set_target(target);
     params->set_remote_interfaces(std::move(remote_interfaces));
     params->set_local_interfaces(std::move(local_interfaces));
     params->set_client_process_connection(std::move(client_process_connection));
     params->set_connect_callback(callback);
-    service_manager_->Connect(std::move(params));
+    service_manager_->Connect(
+        std::move(params), nullptr, weak_factory_.GetWeakPtr());
   }
 
   void Clone(mojom::ConnectorRequest request) override {
     connectors_.AddBinding(this, std::move(request));
   }
 
   // mojom::PIDReceiver:
   void SetPID(uint32_t pid) override {
     PIDAvailable(pid);
   }
@@ skipping 215 matching lines @@
     OnInstanceError(identity_to_instance_.begin()->second);
   identity_to_resolver_.clear();
 }
 
 void ServiceManager::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params) {
-  Connect(std::move(params), nullptr);
+  Connect(std::move(params), nullptr, nullptr);
 }
 
 mojom::ServiceRequest ServiceManager::StartEmbedderService(
     const std::string& name) {
   std::unique_ptr<ConnectParams> params(new ConnectParams);
 
   Identity embedder_identity(name, mojom::kRootUserID);
   params->set_source(embedder_identity);
   params->set_target(embedder_identity);
 
   mojom::ServicePtr service;
   mojom::ServiceRequest request = mojo::GetProxy(&service);
-  Connect(std::move(params), std::move(service));
+  Connect(std::move(params), std::move(service), nullptr);
 
   return request;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManager, Service implementation:
 
 bool ServiceManager::OnConnect(Connection* connection) {
   // The only interface we expose is mojom::ServiceManager, and access to this
   // interface is brokered by a policy specific to each caller, managed by the
@@ skipping 54 matching lines @@
   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) {
+                             mojom::ServicePtr service,
+                             base::WeakPtr<Instance> source_instance) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ServiceManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(IsValidName(params->target().name()));
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
   DCHECK(!service.is_bound() || !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
   if (!service.is_bound() && ConnectToExistingInstance(&params))
     return;
 
   // The catalog needs to see the source identity as that of the originating
   // app so it loads the correct store. Since the catalog is itself run as root
   // when this re-enters Connect() it'll be handled by
   // ConnectToExistingInstance().
   mojom::Resolver* resolver =
       GetResolver(Identity(kServiceManagerName, params->target().user_id()));
 
   std::string name = params->target().name();
   resolver->ResolveMojoName(
       name, base::Bind(&shell::ServiceManager::OnGotResolvedName,
                        weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
-                       base::Passed(&service)));
+                       base::Passed(&service), !!source_instance,
+                       source_instance));
 }
 
 ServiceManager::Instance* ServiceManager::GetExistingInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
   if (instance)
     return instance;
 
   if (singletons_.find(identity.name()) != singletons_.end()) {
@@ skipping 77 matching lines @@
 
 void ServiceManager::OnServiceFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = service_factories_.find(which);
   DCHECK(it != service_factories_.end());
   service_factories_.erase(it);
 }
 
 void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
                                        mojom::ServicePtr service,
+                                       bool has_source_instance,
+                                       base::WeakPtr<Instance> source_instance,
                                        mojom::ResolveResultPtr result) {
+  // If this request was originated by a specific Instance and that Instance is
+  // no longer around, we ignore this response.
+  if (has_source_instance && !source_instance)
+    return;
+
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
       result->qualifier != GetNamePath(result->resolved_name)) {
     instance_name = result->qualifier;
   }
   Identity target(params->target().name(), params->target().user_id(),
                   instance_name);
   params->set_target(target);
 
   // It's possible that when this manifest request was issued, another one was
@@ skipping 42 matching lines @@
         std::move(client_process_connection));
   } else {
     // Otherwise we create a new Service pipe.
     mojom::ServiceRequest request = GetProxy(&service);
     CHECK(!result->package_path.empty() && !result->capabilities.is_null());
 
     if (target.name() != result->resolved_name) {
       instance->StartWithService(std::move(service));
       Identity factory(result->resolved_name, target.user_id(),
                        instance_name);
-      CreateServiceWithFactory(factory, target.name(),
-                                   std::move(request));
+      CreateServiceWithFactory(factory, target.name(), std::move(request));
     } else {
       instance->StartWithFilePath(result->package_path);
     }
   }
 
   // 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