7/ Eliminate on_application_end from ConnectParams

mojo/shell/application_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 MOJO_SHELL_APPLICATION_MANAGER_H_
 #define MOJO_SHELL_APPLICATION_MANAGER_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 53 matching lines @@
   // |task_runner| provides access to a thread to perform file copy operations
   // on. This may be null only in testing environments where applications are
   // loaded via ApplicationLoader implementations.
   // When |register_mojo_url_schemes| is true, mojo: and exe: URL schems are
   // registered as "standard" which faciliates resolving.
   ApplicationManager(scoped_ptr<NativeRunnerFactory> native_runner_factory,
                      base::TaskRunner* task_runner,
                      bool register_mojo_url_schemes);
   ~ApplicationManager() override;
 
+  // Provide a callback to be notified whenever an instance is destroyed.
+  // Typically the creator of the ApplicationManager will use this to determine
+  // when some set of instances it created are destroyed, so it can shut down.
+  void SetInstanceQuitCallback(base::Callback<void(const Identity&)> callback);
+
   // 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.
   void Connect(scoped_ptr<ConnectParams> params);
 
   // Sets the default Loader to be used if not overridden by SetLoaderForURL().
   void set_default_loader(scoped_ptr<ApplicationLoader> loader) {
     default_loader_ = std::move(loader);
   }
 
@@ skipping 34 matching lines @@
 
   void InitPackageManager(bool register_mojo_url_schemes);
 
   // 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.
   bool ConnectToExistingInstance(scoped_ptr<ConnectParams>* params);
 
   ApplicationInstance* CreateInstance(
       const Identity& target_id,
-      const base::Closure& on_application_end,
       const String& application_name,
       mojom::ShellClientRequest* request);
 
   void CreateShellClient(const Identity& source,
                          const Identity& shell_client_factory,
                          const GURL& url,
                          mojom::ShellClientRequest request);
   // Returns a running ShellClientFactory for |shell_client_factory_identity|,
   // if there is not one running one is started for |source_identity|.
   mojom::ShellClientFactory* GetShellClientFactory(
@@ skipping 39 matching lines @@
   scoped_ptr<ApplicationLoader> default_loader_;
 
   IdentityToInstanceMap identity_to_instance_;
 
   IdentityToShellClientFactoryMap shell_client_factories_;
   // Counter used to assign ids to content handlers.
   uint32_t shell_client_factory_id_counter_;
 
   WeakInterfacePtrSet<mojom::ApplicationManagerListener> listeners_;
 
+  base::Callback<void(const Identity&)> instance_quit_callback_;
   base::TaskRunner* task_runner_;
   scoped_ptr<NativeRunnerFactory> native_runner_factory_;
   std::vector<scoped_ptr<NativeRunner>> native_runners_;
   WeakBindingSet<mojom::ApplicationManager> bindings_;
   base::WeakPtrFactory<ApplicationManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationManager);
 };
 
 mojom::Shell::ConnectCallback EmptyConnectCallback();
 
 }  // namespace shell
 }  // namespace mojo
 
 #endif  // MOJO_SHELL_APPLICATION_MANAGER_H_