Disk cache: Add support for an extra data stream for each cache entry....

net/disk_cache/entry_impl.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/disk_cache/entry_impl.h"
 
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
+// Index for the file used to store the key, if any (files_[kKeyFileIndex]).
+const int kKeyFileIndex = 3;
+
 // This class implements FileIOCallback to buffer the callback from a file IO
 // operation from the actual net class.
 class SyncCallback: public disk_cache::FileIOCallback {
  public:
   SyncCallback(disk_cache::EntryImpl* entry,
                net::CompletionCallback* callback )
       : entry_(entry), callback_(callback) {
     entry->AddRef();
     entry->IncrementIoCount();
   }
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryImpl::EntryImpl(BackendImpl* backend, Addr address)
     : entry_(NULL, Addr(0)), node_(NULL, Addr(0)) {
   entry_.LazyInit(backend->File(address), address);
   doomed_ = false;
   backend_ = backend;
-  unreported_size_[0] = unreported_size_[1] = 0;
+  for (int i = 0; i < NUM_STREAMS; i++)
+    unreported_size_[i] = 0;
 }
 
 // When an entry is deleted from the cache, we clean up all the data associated
 // with it for two reasons: to simplify the reuse of the block (we know that any
 // unused block is filled with zeros), and to simplify the handling of write /
 // read partial information from an entry (don't have to worry about returning
 // data related to a previous cache entry because the range was not fully
 // written before).
 EntryImpl::~EntryImpl() {
   if (doomed_) {
     UMA_HISTOGRAM_COUNTS(L"DiskCache.DeleteHeader", GetDataSize(0));
     UMA_HISTOGRAM_COUNTS(L"DiskCache.DeleteData", GetDataSize(1));
-    for (int index = 0; index < kKeyFileIndex; index++) {
+    for (int index = 0; index < NUM_STREAMS; index++) {
       Addr address(entry_.Data()->data_addr[index]);
       if (address.is_initialized()) {
         DeleteData(address, index);
         backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
                                         unreported_size_[index], 0);
       }
     }
     Addr address(entry_.Data()->long_key);
     DeleteData(address, kKeyFileIndex);
     backend_->ModifyStorageSize(entry_.Data()->key_len, 0);
 
     memset(node_.buffer(), 0, node_.size());
     memset(entry_.buffer(), 0, entry_.size());
     node_.Store();
     entry_.Store();
 
     backend_->DeleteBlock(node_.address(), false);
     backend_->DeleteBlock(entry_.address(), false);
   } else {
     bool ret = true;
-    for (int index = 0; index < kKeyFileIndex; index++) {
+    for (int index = 0; index < NUM_STREAMS; index++) {
       if (user_buffers_[index].get()) {
         if (!(ret = Flush(index, entry_.Data()->data_size[index], false)))
           LOG(ERROR) << "Failed to save user data";
       } else if (unreported_size_[index]) {
         backend_->ModifyStorageSize(
             entry_.Data()->data_size[index] - unreported_size_[index],
             entry_.Data()->data_size[index]);
       }
     }
     if (node_.HasData() && this == node_.Data()->pointer) {
@@ skipping 27 matching lines @@
 
 void EntryImpl::Close() {
   Release();
 }
 
 std::string EntryImpl::GetKey() const {
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   if (entry->Data()->key_len > kMaxInternalKeyLength) {
     Addr address(entry->Data()->long_key);
     DCHECK(address.is_initialized());
+    COMPILE_ASSERT(NUM_STREAMS == kKeyFileIndex, invalid_key_index);
     File* file = const_cast<EntryImpl*>(this)->GetBackingFile(address,
                                                               kKeyFileIndex);
 
     size_t offset = 0;
     if (address.is_block_file())
       offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
     std::string key;
     if (!file || !file->Read(WriteInto(&key, entry->Data()->key_len + 1),
                              entry->Data()->key_len + 1, offset))
       key.clear();
     return key;
   } else {
     return std::string(entry->Data()->key);
   }
 }
 
 Time EntryImpl::GetLastUsed() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_used);
 }
 
 Time EntryImpl::GetLastModified() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_modified);
 }
 
 int32 EntryImpl::GetDataSize(int index) const {
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
 int EntryImpl::ReadData(int index, int offset, char* buf, int buf_len,
                         net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   Time start = Time::Now();
@@ skipping 45 matching lines @@
     io_callback->Discard();
 
   stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::WriteData(int index, int offset, const char* buf, int buf_len,
                          net::CompletionCallback* completion_callback,
                          bool truncate) {
   DCHECK(node_.Data()->dirty);
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
@@ skipping 93 matching lines @@
   memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks());
   memset(node, 0, sizeof(RankingsNode));
   if (!node_.LazyInit(backend_->File(node_address), node_address))
     return false;
 
   entry_store->rankings_node = node_address.value();
   node->contents = entry_.address().value();
   node->pointer = this;
 
   entry_store->hash = hash;
+  entry_store->creation_time = Time::Now().ToInternalValue();
   entry_store->key_len = static_cast<int32>(key.size());
   if (entry_store->key_len > kMaxInternalKeyLength) {
     Addr address(0);
     if (!CreateBlock(entry_store->key_len + 1, &address))
       return false;
 
     entry_store->long_key = address.value();
     File* file = GetBackingFile(address, kKeyFileIndex);
 
     size_t offset = 0;
@@ skipping 115 matching lines @@
 }
 
 void EntryImpl::SetTimes(base::Time last_used, base::Time last_modified) {
   node_.Data()->last_used = last_used.ToInternalValue();
   node_.Data()->last_modified = last_modified.ToInternalValue();
   node_.set_modified();
 }
 
 bool EntryImpl::CreateDataBlock(int index, int size) {
   Addr address(entry_.Data()->data_addr[index]);
-  DCHECK(0 == index || 1 == index);
+  DCHECK(index >= 0 && index < NUM_STREAMS);
 
   if (!CreateBlock(size, &address))
     return false;
 
   entry_.Data()->data_addr[index] = address.value();
   entry_.Store();
   return true;
 }
 
 bool EntryImpl::CreateBlock(int size, Addr* address) {
@@ skipping 49 matching lines @@
 File* EntryImpl::GetBackingFile(Addr address, int index) {
   File* file;
   if (address.is_separate_file())
     file = GetExternalFile(address, index);
   else
     file = backend_->File(address);
   return file;
 }
 
 File* EntryImpl::GetExternalFile(Addr address, int index) {
-  DCHECK(index >= 0 && index <= 2);
+  DCHECK(index >= 0 && index <= kKeyFileIndex);
   if (!files_[index].get()) {
     // For a key file, use mixed mode IO.
-    scoped_refptr<File> file(new File(2 == index));
+    scoped_refptr<File> file(new File(kKeyFileIndex == index));
     if (file->Init(backend_->GetFileName(address)))
       files_[index].swap(file);
   }
   return files_[index].get();
 }
 
 bool EntryImpl::PrepareTarget(int index, int offset, int buf_len,
                               bool truncate) {
   Addr address(entry_.Data()->data_addr[index]);
   if (address.is_initialized() || user_buffers_[index].get())
@@ skipping 172 matching lines @@
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%p 0x%x", doomed_, pointer, dirty);
 }
 
 }  // namespace disk_cache