Disk cache: Switch the disk cache to use the cache_thread....

net/disk_cache/entry_impl.cc

 // Copyright (c) 2006-2010 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/io_buffer.h"
@@ skipping 71 matching lines @@
 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;
   for (int i = 0; i < kNumStreams; i++) {
     unreported_size_[i] = 0;
   }
-  key_file_ = NULL;
 }
 
 // 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() {
   // Save the sparse info to disk before deleting this entry.
@@ skipping 21 matching lines @@
       node_.Store();
     } else if (node_.HasData() && node_.Data()->dirty) {
       node_.Data()->dirty = 0;
       node_.Store();
     }
   }
 
   backend_->CacheEntryDestroyed(entry_.address());
 }
 
-void EntryImpl::Doom() {
+void EntryImpl::DoomImpl() {
   if (doomed_)
     return;
 
   SetPointerForInvalidEntry(backend_->GetCurrentEntryId());
   backend_->InternalDoomEntry(this);
 }
 
+void EntryImpl::Doom() {
+  backend_->background_queue()->DoomEntryImpl(this);
+}
+
 void EntryImpl::Close() {
-  Release();
+  backend_->background_queue()->CloseEntryImpl(this);
 }
 
 std::string EntryImpl::GetKey() const {
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   if (entry->Data()->key_len <= kMaxInternalKeyLength)
     return std::string(entry->Data()->key);
 
+  // We keep a copy of the key so that we can always return it, even if the
+  // backend is disabled.
+  if (!key_.empty())
+    return key_;
+
   Addr address(entry->Data()->long_key);
   DCHECK(address.is_initialized());
   size_t offset = 0;
   if (address.is_block_file())
     offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
-  if (!key_file_) {
-    // We keep a copy of the file needed to access the key so that we can
-    // always return this object's key, even if the backend is disabled.
-    COMPILE_ASSERT(kNumStreams == kKeyFileIndex, invalid_key_index);
-    key_file_ = const_cast<EntryImpl*>(this)->GetBackingFile(address,
-                                                             kKeyFileIndex);
-  }
+  COMPILE_ASSERT(kNumStreams == kKeyFileIndex, invalid_key_index);
+  File* key_file = const_cast<EntryImpl*>(this)->GetBackingFile(address,
+                                                                kKeyFileIndex);
 
-  std::string key;
-  if (!key_file_ ||
-      !key_file_->Read(WriteInto(&key, entry->Data()->key_len + 1),
-                       entry->Data()->key_len + 1, offset))
-    key.clear();
-  return key;
+  if (!key_file ||
+      !key_file->Read(WriteInto(&key_, entry->Data()->key_len + 1),
+                      entry->Data()->key_len + 1, offset))
+    key_.clear();
+  return 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 >= kNumStreams)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
-int EntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                        net::CompletionCallback* completion_callback) {
+int EntryImpl::ReadDataImpl(int index, int offset, net::IOBuffer* buf,
+                            int buf_len, CompletionCallback* callback) {
   DCHECK(node_.Data()->dirty);
   if (index < 0 || index >= kNumStreams)
     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;
@@ skipping 23 matching lines @@
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FAILED;
 
   size_t file_offset = offset;
   if (address.is_block_file())
     file_offset += address.start_block() * address.BlockSize() +
                    kBlockHeaderSize;
 
   SyncCallback* io_callback = NULL;
-  if (completion_callback)
-    io_callback = new SyncCallback(this, buf, completion_callback);
+  if (callback)
+    io_callback = new SyncCallback(this, buf, callback);
 
   bool completed;
   if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   ReportIOTime(kRead, start);
-  return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
+  return (completed || !callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                         net::CompletionCallback* completion_callback,
-                         bool truncate) {
+int EntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
+                        net::CompletionCallback* callback) {
+  if (!callback)
+    return ReadDataImpl(index, offset, buf, buf_len, callback);
+
+  DCHECK(node_.Data()->dirty);
+  if (index < 0 || index >= kNumStreams)
+    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;
+
+  backend_->background_queue()->ReadData(this, index, offset, buf, buf_len,
+                                         callback);
+  return net::ERR_IO_PENDING;
+}
+
+int EntryImpl::WriteDataImpl(int index, int offset, net::IOBuffer* buf,
+                             int buf_len, CompletionCallback* callback,
+                             bool truncate) {
   DCHECK(node_.Data()->dirty);
   if (index < 0 || index >= kNumStreams)
     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.
+  // offset or buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
     int size = offset + buf_len;
     if (size <= max_file_size)
       size = kint32max;
     backend_->TooMuchStorageRequested(size);
     return net::ERR_FAILED;
   }
 
   TimeTicks start = TimeTicks::Now();
@@ skipping 49 matching lines @@
                    kBlockHeaderSize;
   } else if (truncate) {
     if (!file->SetLength(offset + buf_len))
       return net::ERR_FAILED;
   }
 
   if (!buf_len)
     return 0;
 
   SyncCallback* io_callback = NULL;
-  if (completion_callback)
-    io_callback = new SyncCallback(this, buf, completion_callback);
+  if (callback)
+    io_callback = new SyncCallback(this, buf, callback);
 
   bool completed;
   if (!file->Write(buf->data(), buf_len, file_offset, io_callback,
                    &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   ReportIOTime(kWrite, start);
-  return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
+  return (completed || !callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
-int EntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                              net::CompletionCallback* completion_callback) {
+int EntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
+                         CompletionCallback* callback, bool truncate) {
+  if (!callback)
+    return WriteDataImpl(index, offset, buf, buf_len, callback, truncate);
+
+  DCHECK(node_.Data()->dirty);
+  if (index < 0 || index >= kNumStreams)
+    return net::ERR_INVALID_ARGUMENT;
+
+  if (offset < 0 || buf_len < 0)
+    return net::ERR_INVALID_ARGUMENT;
+
+  backend_->background_queue()->WriteData(this, index, offset, buf, buf_len,
+                                          truncate, callback);
+  return net::ERR_IO_PENDING;
+}
+
+int EntryImpl::ReadSparseDataImpl(int64 offset, net::IOBuffer* buf, int buf_len,
+                                  CompletionCallback* callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
-                            completion_callback);
+                            callback);
   ReportIOTime(kSparseRead, start);
   return result;
 }
 
-int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                               net::CompletionCallback* completion_callback) {
+int EntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
+                              net::CompletionCallback* callback) {
+  if (!callback)
+    return ReadSparseDataImpl(offset, buf, buf_len, callback);
+
+  backend_->background_queue()->ReadSparseData(this, offset, buf, buf_len,
+                                               callback);
+  return net::ERR_IO_PENDING;
+}
+
+int EntryImpl::WriteSparseDataImpl(int64 offset, net::IOBuffer* buf,
+                                   int buf_len, CompletionCallback* callback) {
   DCHECK(node_.Data()->dirty);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
-                            buf_len, completion_callback);
+                            buf_len, callback);
   ReportIOTime(kSparseWrite, start);
   return result;
 }
 
+int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
+                               net::CompletionCallback* callback) {
+  if (!callback)
+    return WriteSparseDataImpl(offset, buf, buf_len, callback);
+
+  backend_->background_queue()->WriteSparseData(this, offset, buf, buf_len,
+                                                callback);
+  return net::ERR_IO_PENDING;
+}
+
+int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) {
+  return GetAvailableRange(offset, len, start);
+}
+
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start) {
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   return sparse_->GetAvailableRange(offset, len, start);
 }
 
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
                                  CompletionCallback* callback) {
-  return GetAvailableRange(offset, len, start);
+  backend_->background_queue()->GetAvailableRange(this, offset, len, start,
+                                                  callback);
+  return net::ERR_IO_PENDING;
 }
 
 bool EntryImpl::CouldBeSparse() const {
   if (sparse_.get())
     return true;
 
   scoped_ptr<SparseControl> sparse;
   sparse.reset(new SparseControl(const_cast<EntryImpl*>(this)));
   return sparse->CouldBeSparse();
 }
 
 void EntryImpl::CancelSparseIO() {
+  backend_->background_queue()->CancelSparseIO(this);
+}
+
+void EntryImpl::CancelSparseIOImpl() {
   if (!sparse_.get())
     return;
 
   sparse_->CancelIO();
 }
 
-int EntryImpl::ReadyForSparseIO(net::CompletionCallback* completion_callback) {
+int EntryImpl::ReadyForSparseIOImpl(CompletionCallback* callback) {
+  return sparse_->ReadyToUse(callback);
+}
+
+int EntryImpl::ReadyForSparseIO(net::CompletionCallback* callback) {
   if (!sparse_.get())
     return net::OK;
 
-  return sparse_->ReadyToUse(completion_callback);
+  backend_->background_queue()->ReadyForSparseIO(this, callback);
+  return net::ERR_IO_PENDING;
 }
 
 // ------------------------------------------------------------------------
 
 uint32 EntryImpl::GetHash() {
   return entry_.Data()->hash;
 }
 
 bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
                             uint32 hash) {
@@ skipping 10 matching lines @@
 
   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();
-    key_file_ = GetBackingFile(address, kKeyFileIndex);
+    File* key_file = GetBackingFile(address, kKeyFileIndex);
+    key_ = key;
 
     size_t offset = 0;
     if (address.is_block_file())
       offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
-    if (!key_file_ || !key_file_->Write(key.data(), key.size(), offset)) {
+    if (!key_file || !key_file->Write(key.data(), key.size(), offset)) {
       DeleteData(address, kKeyFileIndex);
       return false;
     }
 
     if (address.is_separate_file())
-      key_file_->SetLength(key.size() + 1);
+      key_file->SetLength(key.size() + 1);
   } else {
     memcpy(entry_store->key, key.data(), key.size());
     entry_store->key[key.size()] = '\0';
   }
   backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
   node->dirty = backend_->GetCurrentEntryId();
   Log("Create Entry ");
   return true;
 }
 
@@ skipping 465 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         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%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache