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

net/http/http_cache.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 <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 100 matching lines @@
     while (v.GetNext()) {
       if (LowerCaseEqualsASCII(v.value_begin(), v.value_end(), search->value))
         return true;
     }
   }
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
-std::string HttpCache::GenerateCacheKey(const HttpRequestInfo* request) {
-  std::string url = request->url.spec();
-  if (request->url.has_ref())
-    url.erase(url.find_last_of('#'));
-
-  if (mode_ == NORMAL) {
-    return url;
-  }
-
-  // In playback and record mode, we cache everything.
-
-  // Lazily initialize.
-  if (playback_cache_map_ == NULL)
-    playback_cache_map_.reset(new PlaybackCacheMap());
-
-  // Each time we request an item from the cache, we tag it with a
-  // generation number.  During playback, multiple fetches for the same
-  // item will use the same generation number and pull the proper
-  // instance of an URL from the cache.
-  int generation = 0;
-  DCHECK(playback_cache_map_ != NULL);
-  if (playback_cache_map_->find(url) != playback_cache_map_->end())
-    generation = (*playback_cache_map_)[url];
-  (*playback_cache_map_)[url] = generation + 1;
-
-  // The key into the cache is GENERATION # + METHOD + URL.
-  std::string result = IntToString(generation);
-  result.append(request->method);
-  result.append(url);
-  return result;
-}
-
 //-----------------------------------------------------------------------------
 
 HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e)
     : disk_entry(e),
       writer(NULL),
       will_process_pending_queue(false),
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
@@ skipping 497 matching lines @@
     return true;
 
   // When using the record/playback modes, we always use the cache
   // and we never pass through.
   if (cache_->mode() == RECORD || cache_->mode() == PLAYBACK)
     return false;
 
   if (effective_load_flags_ & LOAD_DISABLE_CACHE)
     return true;
 
-  // TODO(darin): add support for caching HEAD and POST responses
-  if (request_->method != "GET")
-    return true;
+  if (request_->method == "GET")
+    return false;
 
-  return false;
+  if (request_->method == "POST" &&
+      request_->upload_data && request_->upload_data->identifier())
+    return false;
+
+  // TODO(darin): add support for caching HEAD responses
+  return true;
 }
 
 int HttpCache::Transaction::BeginCacheRead() {
   DCHECK(mode_ == READ);
 
   // read response headers
   return HandleResult(ReadResponseInfoFromEntry());
 }
 
 int HttpCache::Transaction::BeginCacheValidation() {
@@ skipping 515 matching lines @@
     response_info->vary_data.Persist(&pickle);
 
   scoped_refptr<WrappedIOBuffer> data = new WrappedIOBuffer(
       reinterpret_cast<const char*>(pickle.data()));
   int len = static_cast<int>(pickle.size());
 
   return disk_entry->WriteData(kResponseInfoIndex, 0, data, len, NULL,
                                true) == len;
 }
 
+// Generate a key that can be used inside the cache.
+std::string HttpCache::GenerateCacheKey(const HttpRequestInfo* request) {
+  std::string url = request->url.spec();
+  if (request->url.has_ref())
+    url.erase(url.find_last_of('#'));
+
+  if (mode_ == NORMAL) {
+    // No valid URL can begin with numerals, so we should not have to worry
+    // about collisions with normal URLs.
+    if (request->upload_data && request->upload_data->identifier())
+      url.insert(0, StringPrintf("%lld/", request->upload_data->identifier()));
+    return url;
+  }
+
+  // In playback and record mode, we cache everything.
+
+  // Lazily initialize.
+  if (playback_cache_map_ == NULL)
+    playback_cache_map_.reset(new PlaybackCacheMap());
+
+  // Each time we request an item from the cache, we tag it with a
+  // generation number.  During playback, multiple fetches for the same
+  // item will use the same generation number and pull the proper
+  // instance of an URL from the cache.
+  int generation = 0;
+  DCHECK(playback_cache_map_ != NULL);
+  if (playback_cache_map_->find(url) != playback_cache_map_->end())
+    generation = (*playback_cache_map_)[url];
+  (*playback_cache_map_)[url] = generation + 1;
+
+  // The key into the cache is GENERATION # + METHOD + URL.
+  std::string result = IntToString(generation);
+  result.append(request->method);
+  result.append(url);
+  return result;
+}
+
 void HttpCache::DoomEntry(const std::string& key) {
   // Need to abandon the ActiveEntry, but any transaction attached to the entry
   // should not be impacted.  Dooming an entry only means that it will no
   // longer be returned by FindActiveEntry (and it will also be destroyed once
   // all consumers are finished with the entry).
   ActiveEntriesMap::iterator it = active_entries_.find(key);
   if (it == active_entries_.end()) {
     disk_cache_->DoomEntry(key);
   } else {
     ActiveEntry* entry = it->second;
@@ skipping 248 matching lines @@
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net