Add two small features to the HttpCache for benchmarking/debugging....

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"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_util.h"
 
 using base::Time;
 
 namespace net {
 
@@ skipping 534 matching lines @@
   DCHECK(rv != ERR_IO_PENDING);
   if (callback_)
     DoCallback(rv);
   return rv;
 }
 
 void HttpCache::Transaction::SetRequest(const HttpRequestInfo* request) {
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
-  // When in playback mode, we want to load exclusively from the cache.
-  if (cache_->mode() == PLAYBACK)
-    effective_load_flags_ |= LOAD_ONLY_FROM_CACHE;
-
-  // When in record mode, we want to NEVER load from the cache.
-  // The reason for this is beacuse we save the Set-Cookie headers
-  // (intentionally).  If we read from the cache, we replay them
-  // prematurely.
-  if (cache_->mode() == RECORD)
-    effective_load_flags_ |= LOAD_BYPASS_CACHE;
+  switch(cache_->mode()) {
+    case NORMAL:
+      break;
+    case RECORD:
+      // When in record mode, we want to NEVER load from the cache.
+      // The reason for this is beacuse we save the Set-Cookie headers
+      // (intentionally).  If we read from the cache, we replay them
+      // prematurely.
+      effective_load_flags_ |= LOAD_BYPASS_CACHE;
+    case PLAYBACK:
+      // When in playback mode, we want to load exclusively from the cache.
+      effective_load_flags_ |= LOAD_ONLY_FROM_CACHE;
+      break;
+    case DISABLE:
+      effective_load_flags_ |= LOAD_DISABLE_CACHE;
+      break;
+  }
 
   // Some headers imply load flags.  The order here is significant.
   //
   //   LOAD_DISABLE_CACHE   : no cache read or write
   //   LOAD_BYPASS_CACHE    : no cache read
   //   LOAD_VALIDATE_CACHE  : no cache read unless validation
   //
   // The former modes trump latter modes, so if we find a matching header we
   // can stop iterating kSpecialHeaders.
   //
@@ skipping 559 matching lines @@
   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('#'));
 
+  DCHECK(mode_ != DISABLE);
   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.
 
@@ skipping 276 matching lines @@
   // Promote next transaction from the pending queue.
   Transaction* next = entry->pending_queue.front();
   if ((next->mode() & Transaction::WRITE) && !entry->readers.empty())
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
+void HttpCache::CloseIdleConnections() {
+  net::HttpNetworkLayer* network =
+      static_cast<net::HttpNetworkLayer*>(network_layer_.get());
+  HttpNetworkSession* session = network->GetSession();
+  if (session) {
+    session->connection_pool()->CloseIdleSockets();
+  }
+}
+
 //-----------------------------------------------------------------------------
 
 }  // namespace net