Cancel ServiceManager connection requests if source Instance dies

services/shell/service_manager.h

 // 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.
 
 #ifndef SERVICES_SHELL_SERVICE_MANAGER_H_
 #define SERVICES_SHELL_SERVICE_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
@@ skipping 84 matching lines @@
   // Removes a Instance when it encounters an error.
   void OnInstanceError(Instance* instance);
 
   // Completes a connection between a source and target application as defined
   // by |params|, exchanging InterfaceProviders between them. If no existing
   // instance of the target application is running, one will be loaded.
   //
   // If |service| is not null, there must not be an instance of the target
   // application already running. The Service Manager will create a new instance
   // and use |service| to control it.
+  //
+  // If |instance| is not null, the lifetime of the connection request is
+  // bounded by that of |instance|. The connection will be cancelled dropped if
+  // |instance| is destroyed.
   void Connect(std::unique_ptr<ConnectParams> params,
-               mojom::ServicePtr service);
+               mojom::ServicePtr service,
+               base::WeakPtr<Instance> source_instance);
 
   // Returns a running instance matching |identity|. This might be an instance
   // running as a different user if one is available that services all users.
   Instance* GetExistingInstance(const Identity& identity) const;
 
   void NotifyPIDAvailable(const Identity& identity, base::ProcessId pid);
 
   // Attempt to complete the connection requested by |params| by connecting to
   // an existing instance. If there is an existing instance, |params| is taken,
   // and this function returns true.
@@ skipping 15 matching lines @@
       const Identity& service_factory_identity);
   void OnServiceFactoryLost(const Identity& which);
 
   // Callback when remote Catalog resolves mojo:foo to mojo:bar.
   // |params| are the params passed to Connect().
   // |service| if provided is a ServicePtr which should be used to manage the
   // new application instance. This may be null.
   // |result| contains the result of the resolve operation.
   void OnGotResolvedName(std::unique_ptr<ConnectParams> params,
                          mojom::ServicePtr service,
+                         bool has_source_instance,
+                         base::WeakPtr<Instance> source_instance,
                          mojom::ResolveResultPtr result);
 
   base::WeakPtr<ServiceManager> GetWeakPtr();
 
   std::map<Identity, Instance*> identity_to_instance_;
 
   // Tracks the names of instances that are allowed to field connection requests
   // from all users.
   std::set<std::string> singletons_;
 
   std::map<Identity, mojom::ServiceFactoryPtr> service_factories_;
   std::map<Identity, mojom::ResolverPtr> identity_to_resolver_;
   mojo::InterfacePtrSet<mojom::ServiceManagerListener> listeners_;
   base::Callback<void(const Identity&)> instance_quit_callback_;
   std::unique_ptr<NativeRunnerFactory> native_runner_factory_;
   std::unique_ptr<ServiceContext> service_context_;
   base::WeakPtrFactory<ServiceManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceManager);
 };
 
 mojom::Connector::ConnectCallback EmptyConnectCallback();
 
 }  // namespace shell
 
 #endif  // SERVICES_SHELL_SERVICE_MANAGER_H_