Revert of Don't use resolved url for instance identity in ApplicationManager

mojo/shell/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 "mojo/shell/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 55 matching lines @@
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     scoped_ptr<ConnectToApplicationParams> params) {
+  GURL original_url = params->app_url();
+  URLRequestPtr original_url_request = params->TakeAppURLRequest();
+
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::ConnectToApplication",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
-                       params->app_url().spec());
-  DCHECK(params->app_url().is_valid());
+                       original_url.spec());
+  DCHECK(original_url.is_valid());
+  DCHECK(original_url_request);
 
-  // Connect to an existing matching instance, if possible.
+  // We need to look for running instances based on both the unresolved and
+  // resolved urls.
   if (ConnectToRunningApplication(&params))
     return;
 
-  ApplicationLoader* loader = GetLoaderForURL(params->app_url());
+  GURL resolved_url = package_manager_->ResolveURL(original_url);
+  params->SetURLInfo(resolved_url);
+  if (ConnectToRunningApplication(&params))
+    return;
+
+  // The application is not running, let's compute the parameters.
+  // NOTE: Set URL info using |original_url_request| instead of |original_url|
+  // because it may contain more information (e.g., it is a POST request).
+  params->SetURLInfo(original_url_request.Pass());
+  ApplicationLoader* loader = GetLoaderForURL(resolved_url);
   if (loader) {
-    GURL url = params->app_url();
-    loader->Load(url, CreateInstance(params.Pass(), nullptr));
+    ConnectToApplicationWithLoader(&params, resolved_url, loader);
     return;
   }
 
-  URLRequestPtr original_url_request = params->TakeAppURLRequest();
+  original_url_request = params->TakeAppURLRequest();
   auto callback =
       base::Bind(&ApplicationManager::HandleFetchCallback,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params));
   package_manager_->FetchRequest(original_url_request.Pass(), callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     scoped_ptr<ConnectToApplicationParams>* params) {
   ApplicationInstance* instance = GetApplicationInstance(
       Identity((*params)->app_url(), (*params)->qualifier()));
   if (!instance)
     return false;
 
   instance->ConnectToClient(params->Pass());
   return true;
 }
 
+void ApplicationManager::ConnectToApplicationWithLoader(
+    scoped_ptr<ConnectToApplicationParams>* params,
+    const GURL& resolved_url,
+    ApplicationLoader* loader) {
+  if (!(*params)->app_url().SchemeIs("mojo"))
+    (*params)->SetURLInfo(resolved_url);
+
+  loader->Load(resolved_url, CreateInstance(params->Pass(), nullptr));
+}
+
 InterfaceRequest<Application> ApplicationManager::CreateInstance(
     scoped_ptr<ConnectToApplicationParams> params,
     ApplicationInstance** resulting_instance) {
   Identity app_identity(params->app_url(), params->qualifier());
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ApplicationInstance* instance = new ApplicationInstance(
       application.Pass(), this, params->originator_identity(), app_identity,
       params->filter(), Shell::kInvalidContentHandlerID,
       params->on_application_end());
   DCHECK(identity_to_instance_.find(app_identity) ==
          identity_to_instance_.end());
   identity_to_instance_[app_identity] = instance;
   instance->InitializeApplication();
   instance->ConnectToClient(params.Pass());
   if (resulting_instance)
     *resulting_instance = instance;
   return application_request.Pass();
 }
 
 ApplicationInstance* ApplicationManager::GetApplicationInstance(
     const Identity& identity) const {
-  const auto& it = identity_to_instance_.find(identity);
-  return it != identity_to_instance_.end() ? it->second : nullptr;
+  const auto& instance_it = identity_to_instance_.find(identity);
+  if (instance_it != identity_to_instance_.end())
+    return instance_it->second;
+  return nullptr;
 }
 
 void ApplicationManager::HandleFetchCallback(
     scoped_ptr<ConnectToApplicationParams> params,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |params| to tell the requestor.
     params->connect_callback().Run(Shell::kInvalidContentHandlerID);
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses the original URL info.
     URLRequestPtr new_request = URLRequest::New();
     new_request->url = redirect_url.spec();
     HttpHeaderPtr header = HttpHeader::New();
     header->name = "Referer";
     header->value = fetcher->GetRedirectReferer().spec();
     new_request->headers.push_back(header.Pass());
     params->SetURLInfo(new_request.Pass());
     ConnectToApplication(params.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(&params))
     return;
 
+  if (params->app_url().scheme() != "mojo")
+    params->SetURLInfo(fetcher->GetURL());
+
   Identity originator_identity = params->originator_identity();
   CapabilityFilter originator_filter = params->originator_filter();
   CapabilityFilter filter = params->filter();
   GURL app_url = params->app_url();
   std::string qualifier = params->qualifier();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> request(CreateInstance(params.Pass(), &app));
@@ skipping 133 matching lines @@
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo