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.
 

[ppi, 2015/11/24 10:47:21]

Is it possible to have an application_manager_unittest for this change?

 #include "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/services/authenticating_url_loader_interceptor/interfaces/authenticating_url_loader_interceptor_meta_factory.mojom.h"
 #include "mojo/services/authentication/interfaces/authentication.mojom.h"
 #include "mojo/services/content_handler/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"
 #include "shell/application_manager/shell_impl.h"
 
 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 kWithQuery = true;
+
 // 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 207 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 with_query) {

[ppi, 2015/11/24 10:47:21]

Why parametrize if we don't call it with |with_query| == false?

[qsr, 2015/11/24 12:24:32]

We do, we have a default value for the parameter.

   static uint64_t unique_id_number = 1;
   bool new_process_per_connection =
       GetNativeApplicationOptionsForURL(
           GetBaseURLAndQuery(resolved_url, nullptr))
           ->new_process_per_connection;
   return new_process_per_connection
-             ? Identity(resolved_url, base::Uint64ToString(unique_id_number++))
-             : Identity(resolved_url);
+             ? Identity(resolved_url, base::Uint64ToString(unique_id_number++),
+                        with_query)
+             : Identity(resolved_url, with_query);
 }
 
 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);
@@ skipping 142 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);
+  Identity content_handler_id =
+      MakeApplicationIdentity(content_handler_url, kWithQuery);
   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 90 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