Clear disk cache when the cache is not initialized

net/http/http_cache.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 <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 849 matching lines @@
       LOG(WARNING) << "Invalid byte range found.";
       effective_load_flags_ |= LOAD_DISABLE_CACHE;
       partial_.reset(NULL);
     }
   }
 }
 
 bool HttpCache::Transaction::ShouldPassThrough() {
   // We may have a null disk_cache if there is an error we cannot recover from,
   // like not enough disk space, or sharing violations.
-  if (!cache_->disk_cache())
+  if (!cache_->disk_cache_.get())
     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;
 
@@ skipping 754 matching lines @@
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      const FilePath& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(
           host_resolver, proxy_service, ssl_config_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
-      in_memory_cache_(false),
       enable_range_support_(true),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      const FilePath& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(session)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
-      in_memory_cache_(false),
       enable_range_support_(true),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HostResolver* host_resolver,
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      int cache_size)
     : mode_(NORMAL),
       type_(MEMORY_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(
           host_resolver, proxy_service, ssl_config_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
-      in_memory_cache_(true),
       enable_range_support_(true),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
                      disk_cache::Backend* disk_cache)
     : mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(network_layer),
       disk_cache_(disk_cache),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
-      in_memory_cache_(false),
       enable_range_support_(true),
       cache_size_(0) {
 }
 
 HttpCache::~HttpCache() {
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
   // won't run (due to our destruction), we can simply ignore the corresponding
   // will_process_pending_queue flag.
   while (!active_entries_.empty()) {
     ActiveEntry* entry = active_entries_.begin()->second;
     entry->will_process_pending_queue = false;
     entry->pending_queue.clear();
     entry->readers.clear();
     entry->writer = NULL;
     DeactivateEntry(entry);
   }
 
   ActiveEntriesSet::iterator it = doomed_entries_.begin();
   for (; it != doomed_entries_.end(); ++it)
     delete *it;
 }
 
+disk_cache::Backend* HttpCache::GetBackend() {
+  if (disk_cache_.get())
+    return disk_cache_.get();
+
+  DCHECK_GE(cache_size_, 0);
+  if (type_ == MEMORY_CACHE) {
+    // We may end up with no folder name and no cache if the initialization
+    // of the disk cache fails. We want to be sure that what we wanted to have
+    // was an in-memory cache.
+    disk_cache_.reset(disk_cache::CreateInMemoryCacheBackend(cache_size_));
+  } else if (!disk_cache_dir_.empty()) {
+    disk_cache_.reset(disk_cache::CreateCacheBackend(disk_cache_dir_, true,
+        cache_size_, type_));
+    disk_cache_dir_ = FilePath();  // Reclaim memory.
+  }
+  return disk_cache_.get();
+}
+
 int HttpCache::CreateTransaction(scoped_ptr<HttpTransaction>* trans) {
   // Do lazy initialization of disk cache if needed.
-  if (!disk_cache_.get()) {
-    DCHECK_GE(cache_size_, 0);
-    if (in_memory_cache_) {
-      // We may end up with no folder name and no cache if the initialization
-      // of the disk cache fails. We want to be sure that what we wanted to have
-      // was an in-memory cache.
-      disk_cache_.reset(disk_cache::CreateInMemoryCacheBackend(cache_size_));
-    } else if (!disk_cache_dir_.empty()) {
-      disk_cache_.reset(disk_cache::CreateCacheBackend(disk_cache_dir_, true,
-          cache_size_, type_));
-      disk_cache_dir_ = FilePath();  // Reclaim memory.
-    }
-  }
+  GetBackend();
   trans->reset(new HttpCache::Transaction(this, enable_range_support_));
   return OK;
 }
 
 HttpCache* HttpCache::GetCache() {
   return this;
 }
 
 HttpNetworkSession* HttpCache::GetSession() {
   net::HttpNetworkLayer* network =
@@ skipping 371 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net