ApplicationManager: Use callback to get notified on application shutdown.

shell/application_manager/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 SHELL_APPLICATION_MANAGER_APPLICATION_MANAGER_H_
 #define SHELL_APPLICATION_MANAGER_APPLICATION_MANAGER_H_
 
 #include <map>
 
 #include "base/macros.h"
@@ skipping 18 matching lines @@
 namespace shell {
 
 class Fetcher;
 class ShellImpl;
 
 class ApplicationManager {
  public:
   class Delegate {
    public:
     virtual ~Delegate();
-    // Send when the Application holding the handle on the other end of the
-    // Shell pipe goes away.
-    virtual void OnApplicationError(const GURL& url);
     virtual GURL ResolveURL(const GURL& url);
     virtual GURL ResolveMappings(const GURL& url);
   };
 
   // API for testing.
   class TestAPI {
    public:
     explicit TestAPI(ApplicationManager* manager);
     ~TestAPI();
 
     // Returns true if the shared instance has been created.
     static bool HasCreatedInstance();
     // Returns true if there is a ShellImpl for this URL.
     bool HasFactoryForURL(const GURL& url) const;
 
    private:
     ApplicationManager* manager_;
 
     DISALLOW_COPY_AND_ASSIGN(TestAPI);
   };
 
   explicit ApplicationManager(Delegate* delegate);
   ~ApplicationManager();
 
   // Loads a service if necessary and establishes a new client connection.
   void ConnectToApplication(const GURL& application_url,
                             const GURL& requestor_url,
                             InterfaceRequest<ServiceProvider> services,
-                            ServiceProviderPtr exposed_services);
+                            ServiceProviderPtr exposed_services,
+                            const base::Closure& on_application_end);
 
   template <typename Interface>
   inline void ConnectToService(const GURL& application_url,
                                InterfacePtr<Interface>* ptr) {
     ScopedMessagePipeHandle service_handle =
         ConnectToServiceByName(application_url, Interface::Name_);
     ptr->Bind(service_handle.Pass());
   }
 
   ScopedMessagePipeHandle ConnectToServiceByName(
@@ skipping 57 matching lines @@
   typedef std::map<GURL, ContentHandlerConnection*> URLToContentHandlerMap;
   typedef std::map<GURL, std::vector<std::string>> URLToArgsMap;
   typedef std::map<std::string, GURL> MimeTypeToURLMap;
   typedef std::map<GURL, NativeRunnerFactory::Options> URLToNativeOptionsMap;
 
   void ConnectToApplicationWithParameters(
       const GURL& application_url,
       const GURL& requestor_url,
       InterfaceRequest<ServiceProvider> services,
       ServiceProviderPtr exposed_services,
+      const base::Closure& on_application_end,
       const std::vector<std::string>& parameters);
 
   bool ConnectToRunningApplication(const GURL& resolved_url,
                                    const GURL& requestor_url,
                                    InterfaceRequest<ServiceProvider>* services,
                                    ServiceProviderPtr* exposed_services);
 
   bool ConnectToApplicationWithLoader(
-      const GURL& requested_url,
       const GURL& resolved_url,
       const GURL& requestor_url,
       InterfaceRequest<ServiceProvider>* services,
       ServiceProviderPtr* exposed_services,
+      const base::Closure& on_application_end,
       const std::vector<std::string>& parameters,
       ApplicationLoader* loader);
 
   InterfaceRequest<Application> RegisterShell(
-      // The original URL requested by client, before any resolution or
-      // redirects.
-      // This is mostly useless and should be removed.
-      const GURL& original_url,
       // The URL after resolution and redirects, including the querystring.
       const GURL& resolved_url,
       const GURL& requestor_url,
       InterfaceRequest<ServiceProvider> services,
       ServiceProviderPtr exposed_services,
+      const base::Closure& on_application_end,
       const std::vector<std::string>& parameters);
 
   ShellImpl* GetShellImpl(const GURL& url);
 
   void ConnectToClient(ShellImpl* shell_impl,
                        const GURL& resolved_url,
                        const GURL& requestor_url,
                        InterfaceRequest<ServiceProvider> services,
                        ServiceProviderPtr exposed_services);
 
-  void HandleFetchCallback(const GURL& requested_url,
-                           const GURL& requestor_url,
+  void HandleFetchCallback(const GURL& requestor_url,
                            InterfaceRequest<ServiceProvider> services,
                            ServiceProviderPtr exposed_services,
+                           const base::Closure& on_application_end,
                            const std::vector<std::string>& parameters,
                            NativeRunner::CleanupBehavior cleanup_behavior,
                            scoped_ptr<Fetcher> fetcher);
 
   void RunNativeApplication(InterfaceRequest<Application> application_request,
                             const NativeRunnerFactory::Options& options,
                             NativeRunner::CleanupBehavior cleanup_behavior,
                             scoped_ptr<Fetcher> fetcher,
                             const base::FilePath& file_path,
                             bool path_exists);
@@ skipping 35 matching lines @@
   bool disable_cache_;
   base::WeakPtrFactory<ApplicationManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationManager);
 };
 
 }  // namespace shell
 }  // namespace mojo
 
 #endif  // SHELL_APPLICATION_MANAGER_APPLICATION_MANAGER_H_