Register application connections under their post-redirect URL.

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 <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 124 matching lines @@
                                      GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
                                      &services, &exposed_services,
                                      default_loader_.get())) {
     return;
   }
 
-  InterfaceRequest<Application> application_request =
-      RegisterShell(requested_url, resolved_url, requestor_url, services.Pass(),
-                    exposed_services.Pass());
-
   auto callback = base::Bind(&ApplicationManager::HandleFetchCallback,
-                             weak_ptr_factory_.GetWeakPtr(),
-                             base::Passed(application_request.Pass()));
+                             weak_ptr_factory_.GetWeakPtr(), requested_url,
+                             requestor_url, base::Passed(services.Pass()),
+                             base::Passed(exposed_services.Pass()));
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(resolved_url,
                      base::Bind(callback, NativeRunner::DontDeleteAppPath));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
 
@@ skipping 59 matching lines @@
     ShellImpl* shell_impl,
     const GURL& url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   shell_impl->ConnectToClient(requestor_url, services.Pass(),
                               exposed_services.Pass());
 }
 
 void ApplicationManager::HandleFetchCallback(
-    InterfaceRequest<Application> application_request,
+    const GURL& requested_url,
+    const GURL& requestor_url,
+    InterfaceRequest<ServiceProvider> services,
+    ServiceProviderPtr exposed_services,
     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!

[qsr, 2015/02/26 10:41:56]

Is there any advantage to try to use the url_loader FollowRedirect method? Given
that it will greatly increase the complexity, I'm not sure it is worth it, but
just asking.

+    ConnectToApplication(redirect_url, requestor_url, services.Pass(),
+                         exposed_services.Pass());
+    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> application_request(
+      RegisterShell(requested_url, fetcher->GetURL(), requestor_url,
+                    services.Pass(), exposed_services.Pass()));
+
   // If the response begins with a #!mojo <content-handler-url>, use it.
-  GURL url;
+  GURL content_handler_url;
   std::string shebang;
-  if (fetcher->PeekContentHandler(&shebang, &url)) {
+  if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     LoadWithContentHandler(
-        url, application_request.Pass(),
+        content_handler_url, application_request.Pass(),
         fetcher->AsURLResponse(blocking_pool_,
                                static_cast<int>(shebang.size())));
     return;
   }
 
   MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
   if (iter != mime_type_to_url_.end()) {
     LoadWithContentHandler(iter->second, application_request.Pass(),
                            fetcher->AsURLResponse(blocking_pool_, 0));
     return;
   }
 
   // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
   // application. That could either mean looking for the platform-specific dll
   // header, or looking for some specific mojo signature prepended to the
   // library.
 
   fetcher->AsPath(blocking_pool_,
                   base::Bind(&ApplicationManager::RunNativeApplication,
                              weak_ptr_factory_.GetWeakPtr(),
                              base::Passed(application_request.Pass()),
                              cleanup_behavior, base::Passed(fetcher.Pass())));

[qsr, 2015/02/26 10:41:56]

I think this is an undefined behavior. You have no guarantee on the order of ->
and .Pass() on fetcher.

 }
 
 void ApplicationManager::RunNativeApplication(
     InterfaceRequest<Application> application_request,
     NativeRunner::CleanupBehavior cleanup_behavior,
     scoped_ptr<Fetcher> fetcher,
     const base::FilePath& path,
     bool path_exists) {
   // We only passed fetcher to keep it alive. Done with it now.
   fetcher.reset();
@@ skipping 123 matching lines @@
     return Array<String>::From(args_it->second);
   return Array<String>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace mojo