Do not use the state as a parameter of the key in the url response cache.

services/url_response_disk_cache/url_response_disk_cache_impl.cc

 // Copyright 2015 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 "services/url_response_disk_cache/url_response_disk_cache_impl.h"
 
 #include <type_traits>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 50 matching lines @@
 
 Array<uint8_t> PathToArray(const base::FilePath& path) {
   if (path.empty())
     return Array<uint8_t>();
   const std::string& string = path.value();
   Array<uint8_t> result(string.size());
   memcpy(&result.front(), string.data(), string.size());
   return result.Pass();
 }
 
+// This method remove the query string of an url if one is present. It does
+// match the behavior of the application manager, which connects to the same app
+// if requested twice with different query parameters.
+std::string CanonicalizeURL(const std::string& url) {
+  GURL gurl(url);
+
+  if (!gurl.has_query()) {
+    return gurl.spec();
+  }
+
+  GURL::Replacements repl;
+  repl.SetQueryStr("");
+  std::string result = gurl.ReplaceComponents(repl).spec();
+  // Remove the dangling '?' because it's ugly.
+  base::ReplaceChars(result, "?", "", &result);
+  return result;
+}
+
 // Encode a string in ascii. This uses _ as an escape character. It also escapes
 // ':' because it is an usual path separator, and '#' because dart refuses it in
 // URLs.
 std::string EncodeString(const std::string& string) {
   std::string result = "";
   for (size_t i = 0; i < string.size(); ++i) {
     unsigned char c = string[i];
     if (c >= 32 && c < 128 && c != '_' && c != ':' && c != '#') {
       result += c;
     } else {
       result += base::StringPrintf("_%02x", c);
     }
   }
   return result;
 }
 
 // This service use a directory under HOME to store all of its data,
 base::FilePath GetBaseDirectory() {
   return base::FilePath(getenv("HOME")).Append(".mojo_url_response_disk_cache");
 }
 
 // Returns the directory used store cached data for the given |url|, under
 // |base_directory|.
 base::FilePath GetDirName(base::FilePath base_directory,
                           const std::string& url) {
   // TODO(qsr): If the speed of directory traversal is problematic, this might
   // need to change to use less directories.
-  return base_directory.Append(EncodeString(url));
+  return base_directory.Append(EncodeString(CanonicalizeURL(url)));
 }
 
 // Returns the directory that the consumer can use to cache its own data.
 base::FilePath GetConsumerCacheDirectory(const base::FilePath& main_cache) {
   return main_cache.Append("consumer_cache");
 }
 
 // Returns the path of the sentinel used to keep track of a zipped response has
 // already been extracted.
 base::FilePath GetExtractedSentinel(const base::FilePath& main_cache) {
@@ skipping 221 matching lines @@
       return;
     }
   }
   // We can ignore write error, as it will just force to clear the cache on the
   // next request.
   WriteFile(GetExtractedSentinel(base_dir), nullptr, 0);
   callback.Run(extracted_dir, cache_dir);
 }
 
 }  // namespace mojo