Strip embedded "#" in URLs when constructing HTTP cache key....

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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 "net/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 15 matching lines @@
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
       : test_mode_(0), doomed_(false), sparse_(false) {
   }
 
-  MockDiskEntry(const std::string& key)
+  explicit MockDiskEntry(const std::string& key)
       : key_(key), doomed_(false), sparse_(false) {
     //
     // 'key' is prefixed with an identifier if it corresponds to a cached POST.
     // Skip past that to locate the actual URL.
     //
     // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
     // URL corresponding to a registered MockTransaction.  It would be good to
     // have another way to access the test_mode.
     //
     GURL url;
@@ skipping 1121 matching lines @@
 
   std::string response_headers;
   RunTransactionTestWithResponse(
       cache.http_cache(), request, &response_headers);
 
   EXPECT_EQ(kNetResponse1.status_and_headers(), response_headers);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  // Request |kUrl| a second first time. Now |kNetResponse1| it is in the HTTP
+  // Request |kUrl| a second time. Now |kNetResponse1| it is in the HTTP
   // cache, so we don't hit the network.
 
   kUnexpectedResponse.AssignTo(&mock_network_response);  // Network mock.
   kNetResponse1.AssignTo(&request);                      // Expected result.
 
   RunTransactionTestWithResponse(
       cache.http_cache(), request, &response_headers);
 
   EXPECT_EQ(kNetResponse1.status_and_headers(), response_headers);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 33 matching lines @@
       cache.http_cache(), request, &response_headers);
 
   EXPECT_EQ(kNetResponse2.status_and_headers(), response_headers);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(2, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&mock_network_response);
 }
 
+TEST(HttpCache, UrlContainingHash) {
+  MockHttpCache cache;
+
+  // Do a typical GET request -- should write an entry into our cache.
+  MockTransaction trans(kTypicalGET_Transaction);
+  RunTransactionTest(cache.http_cache(), trans);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // Request the same URL, but this time with a reference section (hash).
+  // Since the cache key strips the hash sections, this should be a cache hit.
+  std::string url_with_hash = std::string(trans.url) + "#multiple#hashes";
+  trans.url = url_with_hash.c_str();
+  trans.load_flags = net::LOAD_ONLY_FROM_CACHE;
+
+  RunTransactionTest(cache.http_cache(), trans);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+}
+
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
 
   // Test that we skip the cache for POST requests.  Eventually, we will want
   // to cache these, but we'll still have cases where skipping the cache makes
   // sense, so we want to make sure that it works properly.
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
@@ skipping 481 matching lines @@
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }