ApplicationManager: Use callback to get notified on application shutdown.

shell/application_manager/application_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 "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 26 matching lines @@
   std::vector<std::string> result(v1);
   result.insert(result.end(), v1.begin(), v1.end());
   return result;
 }
 
 }  // namespace
 
 ApplicationManager::Delegate::~Delegate() {
 }
 
-void ApplicationManager::Delegate::OnApplicationError(const GURL& url) {
-  LOG(ERROR) << "Communication error with application: " << url.spec();
-}
-
 GURL ApplicationManager::Delegate::ResolveURL(const GURL& url) {
   return url;
 }
 
 GURL ApplicationManager::Delegate::ResolveMappings(const GURL& url) {
   return url;
 }
 
 class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url)
       : manager_(manager), content_handler_url_(content_handler_url) {
     ServiceProviderPtr services;
     manager->ConnectToApplication(content_handler_url, GURL(),
-                                  GetProxy(&services), nullptr);
+                                  GetProxy(&services), nullptr,
+                                  base::Closure());
     MessagePipe pipe;
     content_handler_.Bind(pipe.handle0.Pass());
     services->ConnectToService(ContentHandler::Name_, pipe.handle1.Pass());
     content_handler_.set_error_handler(this);
   }
 
   ContentHandler* content_handler() { return content_handler_.get(); }
 
   GURL content_handler_url() { return content_handler_url_; }
 
@@ skipping 37 matching lines @@
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services) {
-  ConnectToApplicationWithParameters(requested_url, requestor_url,
-                                     services.Pass(), exposed_services.Pass(),
-                                     std::vector<std::string>());
+    ServiceProviderPtr exposed_services,
+    const base::Closure& on_application_end) {
+  ConnectToApplicationWithParameters(
+      requested_url, requestor_url, services.Pass(), exposed_services.Pass(),
+      on_application_end, std::vector<std::string>());
 }
 
 void ApplicationManager::ConnectToApplicationWithParameters(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
+    const base::Closure& on_application_end,
     const std::vector<std::string>& parameters) {
   DCHECK(requested_url.is_valid());
 
   // We check both the mapped and resolved urls for existing shell_impls because
   // external applications can be registered for the unresolved mojo:foo urls.
 
   GURL mapped_url = delegate_->ResolveMappings(requested_url);
   if (ConnectToRunningApplication(mapped_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
   GURL resolved_url = delegate_->ResolveURL(mapped_url);
   if (ConnectToRunningApplication(resolved_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
-  if (ConnectToApplicationWithLoader(requested_url, mapped_url, requestor_url,
-                                     &services, &exposed_services, parameters,
-                                     GetLoaderForURL(mapped_url))) {
+  if (ConnectToApplicationWithLoader(mapped_url, requestor_url, &services,
+                                     &exposed_services, on_application_end,
+                                     parameters, GetLoaderForURL(mapped_url))) {
     return;
   }
 
-  if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
-                                     &services, &exposed_services, parameters,
-                                     GetLoaderForURL(resolved_url))) {
+  if (ConnectToApplicationWithLoader(
+          resolved_url, requestor_url, &services, &exposed_services,
+          on_application_end, parameters, GetLoaderForURL(resolved_url))) {
     return;
   }
 
-  if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
-                                     &services, &exposed_services, parameters,
-                                     default_loader_.get())) {
+  if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
+                                     &exposed_services, on_application_end,
+                                     parameters, default_loader_.get())) {
     return;
   }
 
   auto callback = base::Bind(
       &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
-      requested_url, requestor_url, base::Passed(services.Pass()),
-      base::Passed(exposed_services.Pass()),
+      requestor_url, base::Passed(services.Pass()),
+      base::Passed(exposed_services.Pass()), on_application_end,
       Concatenate(parameters, GetArgsForURL(resolved_url)));
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      base::Bind(callback, NativeRunner::DontDeleteAppPath));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
@@ skipping 17 matching lines @@
   ShellImpl* shell_impl = GetShellImpl(application_url);
   if (!shell_impl)
     return false;
 
   ConnectToClient(shell_impl, resolved_url, requestor_url, services->Pass(),
                   exposed_services->Pass());
   return true;
 }
 
 bool ApplicationManager::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) {
   if (!loader)
     return false;
 
   loader->Load(
       resolved_url,
-      RegisterShell(requested_url, resolved_url, requestor_url,
-                    services->Pass(), exposed_services->Pass(), parameters));
+      RegisterShell(resolved_url, requestor_url, services->Pass(),
+                    exposed_services->Pass(), on_application_end, parameters));
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
-    const GURL& original_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) {
   Identity app_identity(resolved_url);
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ShellImpl* shell =
-      new ShellImpl(application.Pass(), this, original_url, app_identity);
+      new ShellImpl(application.Pass(), this, app_identity, on_application_end);
   identity_to_shell_impl_[app_identity] = shell;
   shell->InitializeApplication(Array<String>::From(
       Concatenate(parameters, GetArgsForURL(app_identity.url))));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request.Pass();
 }
 
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
   const auto& shell_it = identity_to_shell_impl_.find(Identity(url));
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second;
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   shell_impl->ConnectToClient(resolved_url, requestor_url, services.Pass(),
                               exposed_services.Pass());
 }
 
 void ApplicationManager::HandleFetchCallback(
-    const GURL& requested_url,
     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) {
   if (!fetcher) {
     // Network error. Drop |application_request| to tell requestor.
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     ConnectToApplicationWithParameters(redirect_url, requestor_url,
                                        services.Pass(), exposed_services.Pass(),
-                                       parameters);
+                                       on_application_end, parameters);
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   //
   // Also, it's possible the original URL was redirected to an app that is
   // already running.
   if (ConnectToRunningApplication(fetcher->GetURL(), requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
   InterfaceRequest<Application> request(
-      RegisterShell(requested_url, fetcher->GetURL(), requestor_url,
-                    services.Pass(), exposed_services.Pass(), parameters));
+      RegisterShell(fetcher->GetURL(), requestor_url, services.Pass(),
+                    exposed_services.Pass(), on_application_end, parameters));
 
   // If the response begins with a #!mojo <content-handler-url>, use it.
   GURL content_handler_url;
   std::string shebang;
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     LoadWithContentHandler(
         content_handler_url, request.Pass(),
         fetcher->AsURLResponse(blocking_pool_,
                                static_cast<int>(shebang.size())));
     return;
@@ skipping 10 matching lines @@
   // application. That could either mean looking for the platform-specific dll
   // header, or looking for some specific mojo signature prepended to the
   // library.
   // TODO(vtl): (Maybe this should be done by the factory/runner?)
 
   GURL base_resolved_url = GetBaseURLAndQuery(fetcher->GetURL(), nullptr);
   NativeRunnerFactory::Options options;
   if (url_to_native_options_.find(base_resolved_url) !=
       url_to_native_options_.end()) {
     DVLOG(2) << "Applying stored native options to resolved URL "
-             << fetcher->GetURL() << " (requested URL " << requested_url << ")";
+             << fetcher->GetURL();
     options = url_to_native_options_[base_resolved_url];
   }
 
   fetcher->AsPath(
       blocking_pool_,
       base::Bind(&ApplicationManager::RunNativeApplication,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(request.Pass()),
                  options, cleanup_behavior, base::Passed(fetcher.Pass())));
 }
 
@@ skipping 26 matching lines @@
     const GURL& url,
     const std::vector<std::string>& args,
     ApplicationPtr application) {
   const auto& args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end()) {
     LOG(WARNING) << "--args-for provided for external application " << url
                  << " <ignored>";
   }
   Identity identity(url);
   ShellImpl* shell_impl =
-      new ShellImpl(application.Pass(), this, url, identity);
+      new ShellImpl(application.Pass(), this, identity, base::Closure());
   identity_to_shell_impl_[identity] = shell_impl;
   shell_impl->InitializeApplication(Array<String>::From(args));
 }
 
 void ApplicationManager::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
@@ skipping 69 matching lines @@
     return url_it->second;
   auto scheme_it = scheme_to_loader_.find(url.scheme());
   if (scheme_it != scheme_to_loader_.end())
     return scheme_it->second;
   return nullptr;
 }
 
 void ApplicationManager::OnShellImplError(ShellImpl* shell_impl) {
   // Called from ~ShellImpl, so we do not need to call Destroy here.
   const Identity identity = shell_impl->identity();
-  const GURL requested_url = shell_impl->requested_url();
+  base::Closure on_application_end = shell_impl->on_application_end();
   // Remove the shell.
   auto it = identity_to_shell_impl_.find(identity);
   DCHECK(it != identity_to_shell_impl_.end());
   delete it->second;
   identity_to_shell_impl_.erase(it);
-  delegate_->OnApplicationError(requested_url);
+  if (!on_application_end.is_null())
+    on_application_end.Run();
 }
 
 void ApplicationManager::OnContentHandlerError(
     ContentHandlerConnection* content_handler) {
   // Remove the mapping to the content handler.
   auto it =
       url_to_content_handler_.find(content_handler->content_handler_url());
   DCHECK(it != url_to_content_handler_.end());
   delete it->second;
   url_to_content_handler_.erase(it);
 }
 
 ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
-  ConnectToApplication(application_url, GURL(), GetProxy(&services), nullptr);
+  ConnectToApplication(application_url, GURL(), GetProxy(&services), nullptr,
+                       base::Closure());
   MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 std::vector<std::string> ApplicationManager::GetArgsForURL(const GURL& url) {
   const auto& args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end())
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo