Strip query string before applying url mapping.

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"
+#include "shell/application_manager/query_util.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 104 matching lines @@
                                      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()));
 
   if (resolved_url.SchemeIsFile()) {
-    new LocalFetcher(resolved_url, StripQueryFromURL(resolved_url),
+    new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      base::Bind(callback, NativeRunner::DontDeleteAppPath));
     return;
   }
 
   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& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services) {
-  GURL application_url = StripQueryFromURL(resolved_url);
+  GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   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(
@@ skipping 11 matching lines @@
                              services->Pass(), exposed_services->Pass()));
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& original_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
-  GURL app_url = StripQueryFromURL(resolved_url);
+  GURL app_url = GetBaseURLAndQuery(resolved_url, nullptr);
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, original_url, app_url);
   url_to_shell_impl_[app_url] = shell;
   shell->InitializeApplication(GetArgsForURL(original_url));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request.Pass();
@@ skipping 161 matching lines @@
     delete it->second;
   scheme_to_loader_[scheme] = loader.release();
 }
 
 void ApplicationManager::SetArgsForURL(const std::vector<std::string>& args,
                                        const GURL& url) {
   url_to_args_[url] = args;
 }
 
 ApplicationLoader* ApplicationManager::GetLoaderForURL(const GURL& url) {
-  auto url_it = url_to_loader_.find(StripQueryFromURL(url));
+  auto url_it = url_to_loader_.find(GetBaseURLAndQuery(url, nullptr));
   if (url_it != url_to_loader_.end())
     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 NULL;
 }
 
 void ApplicationManager::OnShellImplError(ShellImpl* shell_impl) {
   // Called from ~ShellImpl, so we do not need to call Destroy here.
@@ skipping 33 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