Disk cache: First pass to make it possible to have...

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 565 matching lines @@
   // 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;
 
   // If HttpCache has type MEDIA make sure LOAD_ENABLE_DOWNLOAD_FILE is set,
   // otherwise make sure LOAD_ENABLE_DOWNLOAD_FILE is not set when HttpCache
   // has type other than MEDIA.
-  if (cache_->type() == HttpCache::MEDIA) {
+  if (cache_->type() == MEDIA_CACHE) {
     DCHECK(effective_load_flags_ & LOAD_ENABLE_DOWNLOAD_FILE);
   } else {
     DCHECK(!(effective_load_flags_ & LOAD_ENABLE_DOWNLOAD_FILE));
   }
 
   // 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
@@ skipping 178 matching lines @@
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
     return ERR_FAILED;
 
   // If the cache object is used for media file, we want the file handle of
   // response data.
-  if (cache_->type() == HttpCache::MEDIA) {
+  if (cache_->type() == MEDIA_CACHE) {
     response_.response_data_file =
         entry_->disk_entry->GetPlatformFile(kResponseContentIndex);
   }
 
   return OK;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
                                           IOBuffer* data, int data_len) {
   if (!entry_)
@@ skipping 53 matching lines @@
 
   // If the cache is for media files, we try to prepare the response data
   // file as an external file and truncate it afterwards.
   // Recipient of ResponseInfo should judge from |response_.response_data_file|
   // to tell whether an external file of response data is available for reading
   // or not.
   // TODO(hclam): we should prepare the target stream as extern file only
   // if we get a valid response from server, i.e. 200. We don't want empty
   // cache files for redirection or external files for erroneous requests.
   response_.response_data_file = base::kInvalidPlatformFileValue;
-  if (cache_->type() == HttpCache::MEDIA) {
+  if (cache_->type() == MEDIA_CACHE) {
     response_.response_data_file =
         entry_->disk_entry->UseExternalFile(kResponseContentIndex);
   }
 
   // Truncate the stream.
   WriteToEntry(kResponseContentIndex, 0, NULL, 0);
 }
 
 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
   if (!entry_)
@@ skipping 100 matching lines @@
   HandleResult(result);
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
-      type_(COMMON),
+      type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
-      type_(COMMON),
+      type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(session)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(ProxyService* proxy_service, int cache_size)
     : mode_(NORMAL),
-      type_(COMMON),
+      type_(MEMORY_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(true),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
                      disk_cache::Backend* disk_cache)
     : mode_(NORMAL),
-      type_(COMMON),
+      type_(DISK_CACHE),
       network_layer_(network_layer),
       disk_cache_(disk_cache),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       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
@@ skipping 17 matching lines @@
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     DCHECK(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_));
+                                                       cache_size_, type_));
       disk_cache_dir_.clear();  // Reclaim memory.
     }
   }
   return new HttpCache::Transaction(this);
 }
 
 HttpCache* HttpCache::GetCache() {
   return this;
 }
 
@@ skipping 417 matching lines @@
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net