Disk cache: Add base files for implementation of file format version 3.

net/disk_cache/v3/entry_impl_v3.cc

 // Copyright (c) 2012 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/hash.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/bitmap.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/net_log_parameters.h"
 #include "net/disk_cache/sparse_control.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 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:
-  // |end_event_type| is the event type to log on completion.  Logs nothing on
-  // discard, or when the NetLog is not set to log all events.
-  SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer,
-               const net::CompletionCallback& callback,
-               net::NetLog::EventType end_event_type)
-      : entry_(entry), callback_(callback), buf_(buffer),
-        start_(TimeTicks::Now()), end_event_type_(end_event_type) {
-    entry->AddRef();
-    entry->IncrementIoCount();
-  }
-  virtual ~SyncCallback() {}
-
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
-  void Discard();
-
- private:
-  disk_cache::EntryImpl* entry_;
-  net::CompletionCallback callback_;
-  scoped_refptr<net::IOBuffer> buf_;
-  TimeTicks start_;
-  const net::NetLog::EventType end_event_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyncCallback);
-};
-
-void SyncCallback::OnFileIOComplete(int bytes_copied) {
-  entry_->DecrementIoCount();
-  if (!callback_.is_null()) {
-    if (entry_->net_log().IsLoggingAllEvents()) {
-      entry_->net_log().EndEvent(
-          end_event_type_,
-          disk_cache::CreateNetLogReadWriteCompleteCallback(bytes_copied));
-    }
-    entry_->ReportIOTime(disk_cache::EntryImpl::kAsyncIO, start_);
-    buf_ = NULL;  // Release the buffer before invoking the callback.
-    callback_.Run(bytes_copied);
-  }
-  entry_->Release();
-  delete this;
-}
-
-void SyncCallback::Discard() {
-  callback_.Reset();
-  buf_ = NULL;
-  OnFileIOComplete(0);
-}
-
 const int kMaxBufferSize = 1024 * 1024;  // 1 MB.
 
 }  // namespace
 
 namespace disk_cache {
 
 // This class handles individual memory buffers that store data before it is
 // sent to disk. The buffer can start at any offset, but if we try to write to
 // anywhere in the first 16KB of the file (kMaxBlockSize), we set the offset to
 // zero. The buffer grows up to a size determined by the backend, to keep the
 // total memory used under control.
 class EntryImpl::UserBuffer {
  public:
   explicit UserBuffer(BackendImpl* backend)
       : backend_(backend->GetWeakPtr()), offset_(0), grow_allowed_(true) {
     buffer_.reserve(kMaxBlockSize);
   }
   ~UserBuffer() {
-    if (backend_.get())
+    if (backend_)
       backend_->BufferDeleted(capacity() - kMaxBlockSize);
   }
 
   // Returns true if we can handle writing |len| bytes to |offset|.
   bool PreWrite(int offset, int len);
 
   // Truncates the buffer to |offset| bytes.
   void Truncate(int offset);
 
   // Writes |len| bytes from |buf| at the given |offset|.
@@ skipping 136 matching lines @@
   int available = Size() - start;
   DCHECK_GE(start, 0);
   DCHECK_GE(available, 0);
   len = std::min(len, available);
   memcpy(buf->data() + clean_bytes, &buffer_[start], len);
   return len + clean_bytes;
 }
 
 void EntryImpl::UserBuffer::Reset() {
   if (!grow_allowed_) {
-    if (backend_.get())
+    if (backend_)
       backend_->BufferDeleted(capacity() - kMaxBlockSize);
     grow_allowed_ = true;
     std::vector<char> tmp;
     buffer_.swap(tmp);
     buffer_.reserve(kMaxBlockSize);
   }
   offset_ = 0;
   buffer_.clear();
 }
 
 bool EntryImpl::UserBuffer::GrowBuffer(int required, int limit) {
   DCHECK_GE(required, 0);
   int current_size = capacity();
   if (required <= current_size)
     return true;
 
   if (required > limit)
     return false;
 
-  if (!backend_.get())
+  if (!backend_)
     return false;
 
   int to_add = std::max(required - current_size, kMaxBlockSize * 4);
   to_add = std::max(current_size, to_add);
   required = std::min(current_size + to_add, limit);
 
   grow_allowed_ = backend_->IsAllocAllowed(current_size, required);
   if (!grow_allowed_)
     return false;
 
   DVLOG(3) << "Buffer grow to " << required;
 
   buffer_.reserve(required);
   return true;
 }
 
 // ------------------------------------------------------------------------
 
 EntryImpl::EntryImpl(BackendImpl* backend, Addr address, bool read_only)
     : entry_(NULL, Addr(0)), node_(NULL, Addr(0)),
       backend_(backend->GetWeakPtr()), doomed_(false), read_only_(read_only),
       dirty_(false) {
   entry_.LazyInit(backend->File(address), address);
   for (int i = 0; i < kNumStreams; i++) {
     unreported_size_[i] = 0;
   }
 }
 
-void EntryImpl::DoomImpl() {
-  if (doomed_ || !backend_.get())
-    return;
-
-  SetPointerForInvalidEntry(backend_->GetCurrentEntryId());
-  backend_->InternalDoomEntry(this);
-}
-
-int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
-                            const CompletionCallback& callback) {
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.BeginEvent(
-        net::NetLog::TYPE_ENTRY_READ_DATA,
-        CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
-  }
-
-  int result = InternalReadData(index, offset, buf, buf_len, callback);
-
-  if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_READ_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
-  }
-  return result;
-}
-
-int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback,
-                             bool truncate) {
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.BeginEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
-  }
-
-  int result = InternalWriteData(index, offset, buf, buf_len, callback,
-                                 truncate);
-
-  if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
-  }
-  return result;
-}
-
-int EntryImpl::ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
-                                  const CompletionCallback& callback) {
-  DCHECK(node_.Data()->dirty || read_only_);
-  int result = InitSparseData();
-  if (net::OK != result)
-    return result;
-
-  TimeTicks start = TimeTicks::Now();
-  result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
-                            callback);
-  ReportIOTime(kSparseRead, start);
-  return result;
-}
-
-int EntryImpl::WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
-                                   const CompletionCallback& callback) {
-  DCHECK(node_.Data()->dirty || read_only_);
-  int result = InitSparseData();
-  if (net::OK != result)
-    return result;
-
-  TimeTicks start = TimeTicks::Now();
-  result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
-                            buf_len, callback);
-  ReportIOTime(kSparseWrite, start);
-  return result;
-}
-
-int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) {
-  int result = InitSparseData();
-  if (net::OK != result)
-    return result;
-
-  return sparse_->GetAvailableRange(offset, len, start);
-}
-
-void EntryImpl::CancelSparseIOImpl() {
-  if (!sparse_.get())
-    return;
-
-  sparse_->CancelIO();
-}
-
-int EntryImpl::ReadyForSparseIOImpl(const CompletionCallback& callback) {
-  DCHECK(sparse_.get());
-  return sparse_->ReadyToUse(callback);
-}
-
-uint32 EntryImpl::GetHash() {
-  return entry_.Data()->hash;
-}
-
 bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
                             uint32 hash) {
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
   RankingsNode* node = node_.Data();
   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;
 
@@ skipping 27 matching lines @@
     memcpy(entry_store->key, key.data(), key.size());
     entry_store->key[key.size()] = '\0';
   }
   backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
   CACHE_UMA(COUNTS, "KeySize", 0, static_cast<int32>(key.size()));
   node->dirty = backend_->GetCurrentEntryId();
   Log("Create Entry ");
   return true;
 }
 
+uint32 EntryImpl::GetHash() {
+  return entry_.Data()->hash;
+}
+
 bool EntryImpl::IsSameEntry(const std::string& key, uint32 hash) {
   if (entry_.Data()->hash != hash ||
       static_cast<size_t>(entry_.Data()->key_len) != key.size())
     return false;
 
   return (key.compare(GetKey()) == 0);
 }
 
 void EntryImpl::InternalDoom() {
   net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   DCHECK(node_.HasData());
   if (!node_.Data()->dirty) {
     node_.Data()->dirty = backend_->GetCurrentEntryId();
     node_.Store();
   }
   doomed_ = true;
 }
 
-void EntryImpl::DeleteEntryData(bool everything) {
-  DCHECK(doomed_ || !everything);
-
-  if (GetEntryFlags() & PARENT_ENTRY) {
-    // We have some child entries that must go away.
-    SparseControl::DeleteChildren(this);
-  }
-
-  if (GetDataSize(0))
-    CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
-  if (GetDataSize(1))
-    CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
-  for (int index = 0; index < kNumStreams; index++) {
-    Addr address(entry_.Data()->data_addr[index]);
-    if (address.is_initialized()) {
-      backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
-                                      unreported_size_[index], 0);
-      entry_.Data()->data_addr[index] = 0;
-      entry_.Data()->data_size[index] = 0;
-      entry_.Store();
-      DeleteData(address, index);
-    }
-  }
-
-  if (!everything)
-    return;
-
-  // Remove all traces of this entry.
-  backend_->RemoveEntry(this);
-
-  // Note that at this point node_ and entry_ are just two blocks of data, and
-  // even if they reference each other, nobody should be referencing them.
-
-  Addr address(entry_.Data()->long_key);
-  DeleteData(address, kKeyFileIndex);
-  backend_->ModifyStorageSize(entry_.Data()->key_len, 0);
-
-  backend_->DeleteBlock(entry_.address(), true);
-  entry_.Discard();
-
-  if (!LeaveRankingsBehind()) {
-    backend_->DeleteBlock(node_.address(), true);
-    node_.Discard();
-  }
-}
-
-CacheAddr EntryImpl::GetNextAddress() {
-  return entry_.Data()->next;
-}
-
-void EntryImpl::SetNextAddress(Addr address) {
-  DCHECK_NE(address.value(), entry_.address().value());
-  entry_.Data()->next = address.value();
-  bool success = entry_.Store();
-  DCHECK(success);
-}
-
-bool EntryImpl::LoadNodeAddress() {
-  Addr address(entry_.Data()->rankings_node);
-  if (!node_.LazyInit(backend_->File(address), address))
-    return false;
-  return node_.Load();
-}
-
-bool EntryImpl::Update() {
-  DCHECK(node_.HasData());
-
-  if (read_only_)
-    return true;
-
-  RankingsNode* rankings = node_.Data();
-  if (!rankings->dirty) {
-    rankings->dirty = backend_->GetCurrentEntryId();
-    if (!node_.Store())
-      return false;
-  }
-  return true;
-}
-
-void EntryImpl::SetDirtyFlag(int32 current_id) {
-  DCHECK(node_.HasData());
-  if (node_.Data()->dirty && current_id != node_.Data()->dirty)
-    dirty_ = true;
-
-  if (!current_id)
-    dirty_ = true;
-}
-
-void EntryImpl::SetPointerForInvalidEntry(int32 new_id) {
-  node_.Data()->dirty = new_id;
-  node_.Store();
-}
-
-bool EntryImpl::LeaveRankingsBehind() {
-  return !node_.Data()->contents;
-}
-
 // This only includes checks that relate to the first block of the entry (the
 // first 256 bytes), and values that should be set from the entry creation.
 // Basically, even if there is something wrong with this entry, we want to see
 // if it is possible to load the rankings node and delete them together.
 bool EntryImpl::SanityCheck() {
   if (!entry_.VerifyHash())
     return false;
 
   EntryStore* stored = entry_.Data();
   if (!stored->rankings_node || stored->key_len <= 0)
@@ skipping 86 matching lines @@
         // In general, trust the stored size as it should be in sync with the
         // total size tracked by the backend.
       }
     }
     if (data_size < 0)
       stored->data_size[i] = 0;
   }
   entry_.Store();
 }
 
-void EntryImpl::IncrementIoCount() {
-  backend_->IncrementIoCount();
-}
-
-void EntryImpl::DecrementIoCount() {
-  if (backend_.get())
-    backend_->DecrementIoCount();
-}
-
-void EntryImpl::OnEntryCreated(BackendImpl* backend) {
-  // Just grab a reference to the backround queue.
-  background_queue_ = backend->GetBackgroundQueue();
-}
-
 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();
 }
 
-void EntryImpl::ReportIOTime(Operation op, const base::TimeTicks& start) {
-  if (!backend_.get())
-    return;
-
-  switch (op) {
-    case kRead:
-      CACHE_UMA(AGE_MS, "ReadTime", 0, start);
-      break;
-    case kWrite:
-      CACHE_UMA(AGE_MS, "WriteTime", 0, start);
-      break;
-    case kSparseRead:
-      CACHE_UMA(AGE_MS, "SparseReadTime", 0, start);
-      break;
-    case kSparseWrite:
-      CACHE_UMA(AGE_MS, "SparseWriteTime", 0, start);
-      break;
-    case kAsyncIO:
-      CACHE_UMA(AGE_MS, "AsyncIOTime", 0, start);
-      break;
-    case kReadAsync1:
-      CACHE_UMA(AGE_MS, "AsyncReadDispatchTime", 0, start);
-      break;
-    case kWriteAsync1:
-      CACHE_UMA(AGE_MS, "AsyncWriteDispatchTime", 0, start);
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
 void EntryImpl::BeginLogging(net::NetLog* net_log, bool created) {
   DCHECK(!net_log_.net_log());
   net_log_ = net::BoundNetLog::Make(
       net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY);
   net_log_.BeginEvent(
       net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL,
       CreateNetLogEntryCreationCallback(this, created));
 }
 
 const net::BoundNetLog& EntryImpl::net_log() const {
   return net_log_;
 }
 
-// static
-int EntryImpl::NumBlocksForEntry(int key_size) {
-  // The longest key that can be stored using one block.
-  int key1_len =
-      static_cast<int>(sizeof(EntryStore) - offsetof(EntryStore, key));
-
-  if (key_size < key1_len || key_size > kMaxInternalKeyLength)
-    return 1;
-
-  return ((key_size - key1_len) / 256 + 2);
-}
-
 // ------------------------------------------------------------------------
 
 void EntryImpl::Doom() {
-  if (background_queue_.get())
+  if (background_queue_)
     background_queue_->DoomEntryImpl(this);
 }
 
+void EntryImpl::DoomImpl() {
+  if (doomed_ || !backend_)
+    return;
+
+  SetPointerForInvalidEntry(backend_->GetCurrentEntryId());
+  backend_->InternalDoomEntry(this);
+}
+
 void EntryImpl::Close() {
-  if (background_queue_.get())
+  if (background_queue_)
     background_queue_->CloseEntryImpl(this);
 }
 
 std::string EntryImpl::GetKey() const {
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   int key_len = entry->Data()->key_len;
   if (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
@@ skipping 49 matching lines @@
   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;
 
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadData(this, index, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
+                            const CompletionCallback& callback) {
+  if (net_log_.IsLoggingAllEvents()) {
+    net_log_.BeginEvent(
+        net::NetLog::TYPE_ENTRY_READ_DATA,
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
+  }
+
+  int result = InternalReadData(index, offset, buf, buf_len, callback);
+
+  if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
+    net_log_.EndEvent(
+        net::NetLog::TYPE_ENTRY_READ_DATA,
+        CreateNetLogReadWriteCompleteCallback(result));
+  }
+  return result;
+}
+
 int EntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                          const CompletionCallback& callback, bool truncate) {
   if (callback.is_null())
     return WriteDataImpl(index, offset, buf, buf_len, callback, truncate);
 
   DCHECK(node_.Data()->dirty || read_only_);
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteData(this, index, offset, buf, buf_len, truncate,
                                callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
+                             const CompletionCallback& callback,
+                             bool truncate) {
+  if (net_log_.IsLoggingAllEvents()) {
+    net_log_.BeginEvent(
+        net::NetLog::TYPE_ENTRY_WRITE_DATA,
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
+  }
+
+  int result = InternalWriteData(index, offset, buf, buf_len, callback,
+                                 truncate);
+
+  if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
+    net_log_.EndEvent(
+        net::NetLog::TYPE_ENTRY_WRITE_DATA,
+        CreateNetLogReadWriteCompleteCallback(result));
+  }
+  return result;
+}
+
 int EntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadSparseDataImpl(offset, buf, buf_len, callback);
 
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+                                  const CompletionCallback& callback) {
+  DCHECK(node_.Data()->dirty || read_only_);
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  TimeTicks start = TimeTicks::Now();
+  result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
+                            callback);
+  ReportIOTime(kSparseRead, start);
+  return result;
+}
+
 int EntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   if (callback.is_null())
     return WriteSparseDataImpl(offset, buf, buf_len, callback);
 
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+                                   const CompletionCallback& callback) {
+  DCHECK(node_.Data()->dirty || read_only_);
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  TimeTicks start = TimeTicks::Now();
+  result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
+                            buf_len, callback);
+  ReportIOTime(kSparseWrite, start);
+  return result;
+}
+
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
                                  const CompletionCallback& callback) {
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->GetAvailableRange(this, offset, len, start, callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) {
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  return sparse_->GetAvailableRange(offset, len, start);
+}
+
 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() {
-  if (background_queue_.get())
+  if (background_queue_)
     background_queue_->CancelSparseIO(this);
 }
 
+void EntryImpl::CancelSparseIOImpl() {
+  if (!sparse_.get())
+    return;
+
+  sparse_->CancelIO();
+}
+
 int EntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   if (!sparse_.get())
     return net::OK;
 
-  if (!background_queue_.get())
+  if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadyForSparseIO(this, callback);
   return net::ERR_IO_PENDING;
 }
 
+int EntryImpl::ReadyForSparseIOImpl(const CompletionCallback& callback) {
+  DCHECK(sparse_.get());
+  return sparse_->ReadyToUse(callback);
+}
+
+// ------------------------------------------------------------------------
+
 // 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 (!backend_.get()) {
+  if (!backend_) {
     entry_.clear_modified();
     node_.clear_modified();
     return;
   }
   Log("~EntryImpl in");
 
   // Save the sparse info to disk. This will generate IO for this entry and
   // maybe for a child entry, so it is important to do it before deleting this
   // entry.
   sparse_.reset();
@@ skipping 30 matching lines @@
       node_.Data()->dirty = 0;
       node_.Store();
     }
   }
 
   Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this));
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL);
   backend_->OnEntryDestroyEnd();
 }
 
-// ------------------------------------------------------------------------
-
 int EntryImpl::InternalReadData(int index, int offset,
                                 IOBuffer* buf, int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   DVLOG(2) << "Read from " << index << " at " << offset << " : " << buf_len;
   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;
 
-  if (!backend_.get())
+  if (!backend_)
     return net::ERR_UNEXPECTED;
 
   TimeTicks start = TimeTicks::Now();
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   backend_->OnEvent(Stats::READ_DATA);
@@ skipping 61 matching lines @@
                                  const CompletionCallback& callback,
                                  bool truncate) {
   DCHECK(node_.Data()->dirty || read_only_);
   DVLOG(2) << "Write to " << index << " at " << offset << " : " << buf_len;
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
-  if (!backend_.get())
+  if (!backend_)
     return net::ERR_UNEXPECTED;
 
   int max_file_size = backend_->MaxFileSize();
 
   // 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;
@@ skipping 87 matching lines @@
   if (!CreateBlock(size, &address))
     return false;
 
   entry_.Data()->data_addr[index] = address.value();
   entry_.Store();
   return true;
 }
 
 bool EntryImpl::CreateBlock(int size, Addr* address) {
   DCHECK(!address->is_initialized());
-  if (!backend_.get())
+  if (!backend_)
     return false;
 
   FileType file_type = Addr::RequiredFileType(size);
   if (EXTERNAL == file_type) {
     if (size > backend_->MaxFileSize())
       return false;
     if (!backend_->CreateExternalFile(address))
       return false;
   } else {
     int num_blocks = Addr::RequiredBlocks(size, file_type);
 
     if (!backend_->CreateBlock(file_type, num_blocks, address))
       return false;
   }
   return true;
 }
 
 // Note that this method may end up modifying a block file so upon return the
 // involved block will be free, and could be reused for something else. If there
 // is a crash after that point (and maybe before returning to the caller), the
 // entry will be left dirty... and at some point it will be discarded; it is
 // important that the entry doesn't keep a reference to this address, or we'll
 // end up deleting the contents of |address| once again.
 void EntryImpl::DeleteData(Addr address, int index) {
-  DCHECK(backend_.get());
+  DCHECK(backend_);
   if (!address.is_initialized())
     return;
   if (address.is_separate_file()) {
     int failure = !DeleteCacheFile(backend_->GetFileName(address));
     CACHE_UMA(COUNTS, "DeleteFailed", 0, failure);
     if (failure) {
       LOG(ERROR) << "Failed to delete " <<
           backend_->GetFileName(address).value() << " from the cache.";
     }
-    if (files_[index].get())
+    if (files_[index])
       files_[index] = NULL;  // Releases the object.
   } else {
     backend_->DeleteBlock(address, true);
   }
 }
 
 void EntryImpl::UpdateRank(bool modified) {
-  if (!backend_.get())
+  if (!backend_)
     return;
 
   if (!doomed_) {
     // Everything is handled by the backend.
     backend_->UpdateRank(this, modified);
     return;
   }
 
   Time current = Time::Now();
   node_.Data()->last_used = current.ToInternalValue();
 
   if (modified)
     node_.Data()->last_modified = current.ToInternalValue();
 }
 
-File* EntryImpl::GetBackingFile(Addr address, int index) {
-  if (!backend_.get())
-    return NULL;
+void EntryImpl::DeleteEntryData(bool everything) {
+  DCHECK(doomed_ || !everything);
 
-  File* file;
-  if (address.is_separate_file())
-    file = GetExternalFile(address, index);
-  else
-    file = backend_->File(address);
-  return file;
-}
+  if (GetEntryFlags() & PARENT_ENTRY) {
+    // We have some child entries that must go away.
+    SparseControl::DeleteChildren(this);
+  }
 
-File* EntryImpl::GetExternalFile(Addr address, int index) {
-  DCHECK(index >= 0 && index <= kKeyFileIndex);
-  if (!files_[index].get()) {
-    // For a key file, use mixed mode IO.
-    scoped_refptr<File> file(new File(kKeyFileIndex == index));
-    if (file->Init(backend_->GetFileName(address)))
-      files_[index].swap(file);
+  if (GetDataSize(0))
+    CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
+  if (GetDataSize(1))
+    CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
+  for (int index = 0; index < kNumStreams; index++) {
+    Addr address(entry_.Data()->data_addr[index]);
+    if (address.is_initialized()) {
+      backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
+                                      unreported_size_[index], 0);
+      entry_.Data()->data_addr[index] = 0;
+      entry_.Data()->data_size[index] = 0;
+      entry_.Store();
+      DeleteData(address, index);
+    }
   }
-  return files_[index].get();
+
+  if (!everything)
+    return;
+
+  // Remove all traces of this entry.
+  backend_->RemoveEntry(this);
+
+  // Note that at this point node_ and entry_ are just two blocks of data, and
+  // even if they reference each other, nobody should be referencing them.
+
+  Addr address(entry_.Data()->long_key);
+  DeleteData(address, kKeyFileIndex);
+  backend_->ModifyStorageSize(entry_.Data()->key_len, 0);
+
+  backend_->DeleteBlock(entry_.address(), true);
+  entry_.Discard();
+
+  if (!LeaveRankingsBehind()) {
+    backend_->DeleteBlock(node_.address(), true);
+    node_.Discard();
+  }
 }
 
 // We keep a memory buffer for everything that ends up stored on a block file
 // (because we don't know yet the final data size), and for some of the data
 // that end up on external files. This function will initialize that memory
 // buffer and / or the files needed to store the data.
 //
 // In general, a buffer may overlap data already stored on disk, and in that
 // case, the contents of the buffer are the most accurate. It may also extend
 // the file, but we don't want to read from disk just to keep the buffer up to
@@ skipping 234 matching lines @@
 void EntryImpl::SetEntryFlags(uint32 flags) {
   entry_.Data()->flags |= flags;
   entry_.set_modified();
 }
 
 uint32 EntryImpl::GetEntryFlags() {
   return entry_.Data()->flags;
 }
 
 void EntryImpl::GetData(int index, char** buffer, Addr* address) {
-  DCHECK(backend_.get());
+  DCHECK(backend_);
   if (user_buffers_[index].get() && user_buffers_[index]->Size() &&
       !user_buffers_[index]->Start()) {
     // The data is already in memory, just copy it and we're done.
     int data_len = entry_.Data()->data_size[index];
     if (data_len <= user_buffers_[index]->Size()) {
       DCHECK(!user_buffers_[index]->Start());
       *buffer = new char[data_len];
       memcpy(*buffer, user_buffers_[index]->Data(), data_len);
       return;
     }
   }
 
   // Bad news: we'd have to read the info from disk so instead we'll just tell
   // the caller where to read from.
   *buffer = NULL;
   address->set_value(entry_.Data()->data_addr[index]);
   if (address->is_initialized()) {
     // Prevent us from deleting the block from the backing store.
     backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
                                     unreported_size_[index], 0);
     entry_.Data()->data_addr[index] = 0;
     entry_.Data()->data_size[index] = 0;
   }
 }
 
+void EntryImpl::ReportIOTime(Operation op, const base::TimeTicks& start) {
+  if (!backend_)
+    return;
+
+  switch (op) {
+    case kRead:
+      CACHE_UMA(AGE_MS, "ReadTime", 0, start);
+      break;
+    case kWrite:
+      CACHE_UMA(AGE_MS, "WriteTime", 0, start);
+      break;
+    case kSparseRead:
+      CACHE_UMA(AGE_MS, "SparseReadTime", 0, start);
+      break;
+    case kSparseWrite:
+      CACHE_UMA(AGE_MS, "SparseWriteTime", 0, start);
+      break;
+    case kAsyncIO:
+      CACHE_UMA(AGE_MS, "AsyncIOTime", 0, start);
+      break;
+    case kReadAsync1:
+      CACHE_UMA(AGE_MS, "AsyncReadDispatchTime", 0, start);
+      break;
+    case kWriteAsync1:
+      CACHE_UMA(AGE_MS, "AsyncWriteDispatchTime", 0, start);
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
 void EntryImpl::Log(const char* msg) {
   int dirty = 0;
   if (node_.HasData()) {
     dirty = node_.Data()->dirty;
   }
 
   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