Net module changes to support caching responses to a POST request.

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2008 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/platform_file.h"
 #include "base/string_util.h"
@@ skipping 15 matching lines @@
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
       : test_mode_(0), doomed_(false), platform_file_(global_platform_file_) {
   }
 
   MockDiskEntry(const std::string& key)
       : key_(key), doomed_(false), platform_file_(global_platform_file_) {
-    const MockTransaction* t = FindMockTransaction(GURL(key));
+    //
+    // '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;
+    if (isdigit(key[0])) {
+      size_t slash = key.find('/');
+      DCHECK(slash != std::string::npos);
+      url = GURL(key.substr(slash + 1));
+    } else {
+      url = GURL(key);
+    }
+    const MockTransaction* t = FindMockTransaction(url);
     DCHECK(t);
     test_mode_ = t->test_mode;
   }
 
   ~MockDiskEntry() {
   }
 
   bool is_doomed() const { return doomed_; }
 
   virtual void Doom() {
@@ skipping 220 matching lines @@
 void ReadAndVerifyTransaction(net::HttpTransaction* trans,
                               const MockTransaction& trans_info) {
   std::string content;
   int rv = ReadTransaction(trans, &content);
 
   EXPECT_EQ(net::OK, rv);
   EXPECT_EQ(strlen(trans_info.data), content.size());
   EXPECT_EQ(0, memcmp(trans_info.data, content.data(), content.size()));
 }
 
-void RunTransactionTest(net::HttpCache* cache,
-                        const MockTransaction& trans_info) {
-  MockHttpRequest request(trans_info);
+void RunTransactionTestWithRequest(net::HttpCache* cache,
+                                   const MockTransaction& trans_info,
+                                   const MockHttpRequest& request) {
   TestCompletionCallback callback;
 
   // write to the cache
 
   scoped_ptr<net::HttpTransaction> trans(cache->CreateTransaction());
   ASSERT_TRUE(trans.get());
 
   int rv = trans->Start(&request, &callback);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   ReadAndVerifyTransaction(trans.get(), trans_info);
 }
 
+void RunTransactionTest(net::HttpCache* cache,
+                        const MockTransaction& trans_info) {
+  return RunTransactionTestWithRequest(
+      cache, trans_info, MockHttpRequest(trans_info));
+}
+
 // This class provides a handler for kFastNoStoreGET_Transaction so that the
 // no-store header can be included on demand.
 class FastTransactionServer {
  public:
   FastTransactionServer() {
     no_store = false;
   }
   ~FastTransactionServer() {}
 
   void set_no_store(bool value) { no_store = value; }
@@ skipping 582 matching lines @@
   RunTransactionTest(cache.http_cache(), transaction2);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimplePOST_SkipsCache) {
   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.
+  // Test that we skip the cache for POST requests that do not have an upload
+  // identifier.
 
   RunTransactionTest(cache.http_cache(), kSimplePOST_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
@@ skipping 17 matching lines @@
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
+TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Hit) {
+  MockHttpCache cache;
+
+  // Test that we hit the cache for POST requests.
+
+  MockTransaction transaction(kSimplePOST_Transaction);
+
+  const int64 kUploadId = 1;  // Just a dummy value.
+
+  MockHttpRequest request(transaction);
+  request.upload_data = new net::UploadData();
+  request.upload_data->set_identifier(kUploadId);
+  request.upload_data->AppendBytes("hello", 5);
+
+  // Populate the cache.
+  RunTransactionTestWithRequest(cache.http_cache(), transaction, request);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // Load from cache.
+  request.load_flags |= net::LOAD_ONLY_FROM_CACHE;
+  RunTransactionTestWithRequest(cache.http_cache(), transaction, request);
+
+  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, RangeGET_SkipsCache) {
   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.
 
   RunTransactionTest(cache.http_cache(), kRangeGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 325 matching lines @@
 
     const net::HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response);
 
     // Make sure we get the same file handle as in the first request.
     ASSERT_EQ(kFakePlatformFile1, response->response_data_file);
 
     ReadAndVerifyTransaction(trans.get(), trans_info);
   }
 }