Allows URL queries to be passed to contet handlers.

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 13 matching lines @@
 using mojo::Application;
 using mojo::ApplicationPtr;
 using mojo::InterfaceRequest;
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 
 namespace shell {
 
 namespace {
 
+// Create identity that depends on the query.
+const bool kDoNotStripQuery = false;
+
 // Used by TestAPI.
 bool has_created_instance = false;
 
 std::vector<std::string> Concatenate(const std::vector<std::string>& v1,
                                      const std::vector<std::string>& v2) {
   if (!v1.size())
     return v2;
   if (!v2.size())
     return v1;
   std::vector<std::string> result(v1);
@@ skipping 49 matching lines @@
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
 
 bool ApplicationManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ApplicationManager::TestAPI::HasFactoryForURL(const GURL& url) const {
+  DCHECK(!url.has_query());
   return manager_->identity_to_shell_impl_.find(Identity(url)) !=
          manager_->identity_to_shell_impl_.end();
 }
 
 ApplicationManager::ApplicationManager(const Options& options,
                                        Delegate* delegate)
     : options_(options),
       delegate_(delegate),
       blocking_pool_(nullptr),
       initialized_authentication_interceptor_(false),
@@ skipping 146 matching lines @@
   if (!loader)
     return false;
 
   loader->Load(
       resolved_url,
       RegisterShell(resolved_url, requestor_url, services->Pass(),
                     exposed_services->Pass(), on_application_end, parameters));
   return true;
 }
 
-Identity ApplicationManager::MakeApplicationIdentity(const GURL& resolved_url) {
+Identity ApplicationManager::MakeApplicationIdentity(const GURL& resolved_url,
+                                                     bool strip_query) {
   static uint64_t unique_id_number = 1;
+  GURL stripped_url = GetBaseURLAndQuery(resolved_url, nullptr);
+  GURL url = strip_query ? stripped_url : resolved_url;
   bool new_process_per_connection =
-      GetNativeApplicationOptionsForURL(
-          GetBaseURLAndQuery(resolved_url, nullptr))
+      GetNativeApplicationOptionsForURL(stripped_url)
           ->new_process_per_connection;
   return new_process_per_connection
-             ? Identity(resolved_url, base::Uint64ToString(unique_id_number++))
-             : Identity(resolved_url);
+             ? Identity(url, base::Uint64ToString(unique_id_number++))
+             : Identity(url);
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     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 = MakeApplicationIdentity(resolved_url);
 
   mojo::ApplicationPtr application;
   InterfaceRequest<Application> application_request =
       mojo::GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, app_identity, on_application_end);
   identity_to_shell_impl_[app_identity] = make_scoped_ptr(shell);
   shell->InitializeApplication(mojo::Array<mojo::String>::From(parameters));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request;
 }
 
 // Note: If a service was created with a unique ID, intending to be unique
 // (such that multiple requests for a service result in unique processes), then
 // 'GetShellImpl' should return nullptr.
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
+  DCHECK(!url.has_query());
   const auto& shell_it = identity_to_shell_impl_.find(Identity(url));
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second.get();
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& resolved_url,
     const GURL& requestor_url,
@@ skipping 115 matching lines @@
   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;
 }
 
 void ApplicationManager::LoadWithContentHandler(
     const GURL& content_handler_url,
     InterfaceRequest<Application> application_request,
     mojo::URLResponsePtr url_response) {
   ContentHandlerConnection* connection = nullptr;
-  Identity content_handler_id = MakeApplicationIdentity(content_handler_url);
+  // If two content handler urls differ by query parameter, we want to create a
+  // separate connection for each.
+  Identity content_handler_id =
+      MakeApplicationIdentity(content_handler_url, kDoNotStripQuery);
   auto it = identity_to_content_handler_.find(content_handler_id);
   if (it != identity_to_content_handler_.end()) {
     connection = it->second.get();
   } else {
     connection = new ContentHandlerConnection(this, content_handler_id);
     identity_to_content_handler_[content_handler_id] =
         make_scoped_ptr(connection);
   }
 
   connection->content_handler()->StartApplication(application_request.Pass(),
@@ skipping 85 matching lines @@
     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