Simple multi-url support for mojo apps

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"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
+#include "base/strings/string_util.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/content_handler/public/interfaces/content_handler.mojom.h"
 #include "shell/application_manager/fetcher.h"
 #include "shell/application_manager/local_fetcher.h"
 #include "shell/application_manager/network_fetcher.h"
 
 namespace mojo {
 
 namespace {
 // Used by TestAPI.
 bool has_created_instance = false;
+
+GURL StripQueryFromURL(const GURL& url) {
+  GURL::Replacements repl;
+  repl.SetQueryStr("");
+  std::string result = url.ReplaceComponents(repl).spec();
+
+  // Remove the dangling '?' because it's ugly.
+  base::ReplaceChars(result, "?", "", &result);
+  return GURL(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) {
@@ skipping 69 matching lines @@
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   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)) {
+  if (ConnectToRunningApplication(requested_url, mapped_url, requestor_url,

[qsr, 2015/02/27 15:01:41]

I think the URL that the application see should be the URL after all
mapping/redirect etc. So we should not pass requested_url here but mapped_url
with the needed query string.

[Aaron Boodman, 2015/02/27 16:54:44]

Done.

+                                  &services, &exposed_services)) {
     return;
   }
 
   GURL resolved_url = delegate_->ResolveURL(mapped_url);
-  if (ConnectToRunningApplication(resolved_url, requestor_url, &services,
-                                  &exposed_services)) {
+  if (ConnectToRunningApplication(requested_url, resolved_url, requestor_url,
+                                  &services, &exposed_services)) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(requested_url, mapped_url, requestor_url,
                                      &services, &exposed_services,
                                      GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
@@ skipping 20 matching lines @@
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
 
   new NetworkFetcher(disable_cache_, resolved_url, network_service_.get(),
                      base::Bind(callback, NativeRunner::DeleteAppPath));
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
+    const GURL& requested_url,
     const GURL& application_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services) {
   ShellImpl* shell_impl = GetShellImpl(application_url);

[qsr, 2015/02/27 15:01:41]

Any reason you do not always strip the query here?

[Aaron Boodman, 2015/02/27 16:54:44]

Done.

-  if (!shell_impl)
-    return false;
+  if (!shell_impl) {
+    shell_impl = GetShellImpl(StripQueryFromURL(application_url));
+    if (!shell_impl || !shell_impl->handles_query())
+      return false;
+  }
 
-  ConnectToClient(shell_impl, application_url, requestor_url, services->Pass(),
-                  exposed_services->Pass());
+  ConnectToClient(shell_impl, requested_url, application_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,
     ApplicationLoader* loader) {
   if (!loader)
     return false;
 
   loader->Load(resolved_url,
                RegisterShell(requested_url, resolved_url, requestor_url,
-                             services->Pass(), exposed_services->Pass()));
+                             services->Pass(), exposed_services->Pass(),
+                             ShellImpl::SHELL_DOES_NOT_HANDLE_QUERY));
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& requested_url,
-    const GURL& resolved_url,
+    GURL resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services) {
+    ServiceProviderPtr exposed_services,
+    ShellImpl::QueryHandlingBehavior query_behavior) {
+  if (query_behavior == ShellImpl::SHELL_HANDLES_QUERY)
+    resolved_url = StripQueryFromURL(resolved_url);
+
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
-  ShellImpl* shell =
-      new ShellImpl(application.Pass(), this, requested_url, resolved_url);
+  ShellImpl* shell = new ShellImpl(application.Pass(), this, requested_url,
+                                   resolved_url, query_behavior);
   url_to_shell_impl_[resolved_url] = shell;
   shell->InitializeApplication(GetArgsForURL(requested_url));
-  ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
-                  exposed_services.Pass());
+  ConnectToClient(shell, requested_url, resolved_url, requestor_url,
+                  services.Pass(), exposed_services.Pass());
   return application_request.Pass();
 }
 
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
   const auto& shell_it = url_to_shell_impl_.find(url);
   if (shell_it != url_to_shell_impl_.end())
     return shell_it->second;
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
-    const GURL& url,
+    const GURL& requested_url,
+    const GURL& resolved_url,  // TODO(aa): Remove

[qsr, 2015/02/27 15:01:41]

I think that it is requested_url that we can do without. We just have to make
sure resolved_url is the real url of the shell with the query path.

[Aaron Boodman, 2015/02/27 16:54:44]

Done.

     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
-  shell_impl->ConnectToClient(requestor_url, services.Pass(),
+  shell_impl->ConnectToClient(requested_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,
     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!
     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,
+  if (ConnectToRunningApplication(requested_url, 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 content_handler_url;
   std::string shebang;
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     LoadWithContentHandler(
-        content_handler_url, application_request.Pass(),
+        content_handler_url,
+        // #!mojo means this is a first-class mojo application, so it handles
+        // queries.
+        RegisterShell(requested_url, fetcher->GetURL(), requestor_url,
+                      services.Pass(), exposed_services.Pass(),
+                      ShellImpl::SHELL_HANDLES_QUERY),
         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));
+    // Legacy content doesn't get automatic query handling.
+    LoadWithContentHandler(
+        iter->second,
+        RegisterShell(requested_url, fetcher->GetURL(), requestor_url,
+                      services.Pass(), exposed_services.Pass(),
+                      ShellImpl::SHELL_DOES_NOT_HANDLE_QUERY),
+        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())));
+  fetcher->AsPath(
+      blocking_pool_,
+      base::Bind(
+          &ApplicationManager::RunNativeApplication,
+          weak_ptr_factory_.GetWeakPtr(),
+          base::Passed(RegisterShell(requested_url, fetcher->GetURL(),
+                                     requestor_url, services.Pass(),
+                                     exposed_services.Pass(),
+                                     ShellImpl::SHELL_HANDLES_QUERY).Pass()),
+          cleanup_behavior, base::Passed(fetcher.Pass())));
 }
 
 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 15 matching lines @@
 
 void ApplicationManager::RegisterExternalApplication(
     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>";
   }
-  ShellImpl* shell_impl = new ShellImpl(application.Pass(), this, url, url);
+  ShellImpl* shell_impl = new ShellImpl(application.Pass(), this, url, url,
+                                        ShellImpl::SHELL_DOES_NOT_HANDLE_QUERY);
   url_to_shell_impl_[url] = 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 87 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