Disk cache: Remove all non essential synchronization from the cache destructor.

net/disk_cache/entry_impl.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/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 88 matching lines @@
       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|.
-  void Write(int offset, net::IOBuffer* buf, int len);
+  void Write(int offset, IOBuffer* buf, int len);
 
   // Returns true if we can read |len| bytes from |offset|, given that the
   // actual file has |eof| bytes stored. Note that the number of bytes to read
   // may be modified by this method even though it returns false: that means we
   // should do a smaller read from disk.
   bool PreRead(int eof, int offset, int* len);
 
   // Read |len| bytes from |buf| at the given |offset|.
-  int Read(int offset, net::IOBuffer* buf, int len);
+  int Read(int offset, IOBuffer* buf, int len);
 
   // Prepare this buffer for reuse.
   void Reset();
 
   char* Data() { return buffer_.size() ? &buffer_[0] : NULL; }
   int Size() { return static_cast<int>(buffer_.size()); }
   int Start() { return offset_; }
   int End() { return offset_ + Size(); }
 
  private:
@@ skipping 32 matching lines @@
 void EntryImpl::UserBuffer::Truncate(int offset) {
   DCHECK_GE(offset, 0);
   DCHECK_GE(offset, offset_);
   DVLOG(3) << "Buffer truncate at " << offset << " current " << offset_;
 
   offset -= offset_;
   if (Size() >= offset)
     buffer_.resize(offset);
 }
 
-void EntryImpl::UserBuffer::Write(int offset, net::IOBuffer* buf, int len) {
+void EntryImpl::UserBuffer::Write(int offset, IOBuffer* buf, int len) {
   DCHECK_GE(offset, 0);
   DCHECK_GE(len, 0);
   DCHECK_GE(offset + len, 0);
   DCHECK_GE(offset, offset_);
   DVLOG(3) << "Buffer write at " << offset << " current " << offset_;
 
   if (!Size() && offset > kMaxBlockSize)
     offset_ = offset;
 
   offset -= offset_;
@@ skipping 36 matching lines @@
     return false;
   }
 
   if (!Size())
     return false;
 
   // See if we can fulfill the first part of the operation.
   return (offset - offset_ < Size());
 }
 
-int EntryImpl::UserBuffer::Read(int offset, net::IOBuffer* buf, int len) {
+int EntryImpl::UserBuffer::Read(int offset, IOBuffer* buf, int len) {
   DCHECK_GE(offset, 0);
   DCHECK_GT(len, 0);
   DCHECK(Size() || offset < offset_);
 
   int clean_bytes = 0;
   if (offset < offset_) {
     // We don't have a file so lets fill the first part with 0.
     clean_bytes = std::min(offset_ - offset, len);
     memset(buf->data(), 0, clean_bytes);
     if (len == clean_bytes)
@@ skipping 46 matching lines @@
 
   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),
-      doomed_(false), read_only_(read_only), dirty_(false) {
+    : 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_)
+  if (doomed_ || !backend_)
     return;
 
   SetPointerForInvalidEntry(backend_->GetCurrentEntryId());
   backend_->InternalDoomEntry(this);
 }
 
-int EntryImpl::ReadDataImpl(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback) {
+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,
         make_scoped_refptr(
             new ReadWriteDataParameters(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,
         make_scoped_refptr(new ReadWriteCompleteParameters(result)));
   }
   return result;
 }
 
-int EntryImpl::WriteDataImpl(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback, bool truncate) {
+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,
         make_scoped_refptr(
             new ReadWriteDataParameters(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,
         make_scoped_refptr(new ReadWriteCompleteParameters(result)));
   }
   return result;
 }
 
-int EntryImpl::ReadSparseDataImpl(int64 offset, net::IOBuffer* buf, int buf_len,
-                                  const net::CompletionCallback& callback) {
+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, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback) {
+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 net::CompletionCallback& callback) {
+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) {
@@ skipping 264 matching lines @@
       stored->data_size[i] = 0;
   }
   entry_.Store();
 }
 
 void EntryImpl::IncrementIoCount() {
   backend_->IncrementIoCount();
 }
 
 void EntryImpl::DecrementIoCount() {
-  backend_->DecrementIoCount();
+  if (backend_)
+    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_)
+    return;
+
   int group = backend_->GetSizeGroup();
   switch (op) {
     case kRead:
       CACHE_UMA(AGE_MS, "ReadTime", group, start);
       break;
     case kWrite:
       CACHE_UMA(AGE_MS, "WriteTime", group, start);
       break;
     case kSparseRead:
       CACHE_UMA(AGE_MS, "SparseReadTime", 0, start);
@@ skipping 36 matching lines @@
 
   if (key_size < key1_len || key_size > kMaxInternalKeyLength)
     return 1;
 
   return ((key_size - key1_len) / 256 + 2);
 }
 
 // ------------------------------------------------------------------------
 
 void EntryImpl::Doom() {
-  backend_->background_queue()->DoomEntryImpl(this);
+  if (background_queue_)
+    background_queue_->DoomEntryImpl(this);
 }
 
 void EntryImpl::Close() {
-  backend_->background_queue()->CloseEntryImpl(this);
+  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
   // backend is disabled.
@@ skipping 32 matching lines @@
 }
 
 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,
-                        const net::CompletionCallback& callback) {
+int EntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
+                        const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadDataImpl(index, offset, buf, buf_len, callback);
 
   DCHECK(node_.Data()->dirty || read_only_);
   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);
+  if (!background_queue_)
+    return net::ERR_UNEXPECTED;
+
+  background_queue_->ReadData(this, index, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteData(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback, bool truncate) {
+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;
 
-  backend_->background_queue()->WriteData(this, index, offset, buf, buf_len,
-                                          truncate, callback);
+  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::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                              const net::CompletionCallback& callback) {
+int EntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+                              const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadSparseDataImpl(offset, buf, buf_len, callback);
 
-  backend_->background_queue()->ReadSparseData(this, offset, buf, buf_len,
-                                               callback);
+  if (!background_queue_)
+    return net::ERR_UNEXPECTED;
+
+  background_queue_->ReadSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                               const net::CompletionCallback& callback) {
+int EntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+                               const CompletionCallback& callback) {
   if (callback.is_null())
     return WriteSparseDataImpl(offset, buf, buf_len, callback);
 
-  backend_->background_queue()->WriteSparseData(this, offset, buf, buf_len,
-                                                callback);
+  if (!background_queue_)
+    return net::ERR_UNEXPECTED;
+
+  background_queue_->WriteSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
-                                 const net::CompletionCallback& callback) {
-  backend_->background_queue()->GetAvailableRange(this, offset, len, start,
-                                                  callback);
+                                 const CompletionCallback& callback) {
+  if (!background_queue_)
+    return net::ERR_UNEXPECTED;
+
+  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);
+  if (background_queue_)
+    background_queue_->CancelSparseIO(this);
 }
 
-int EntryImpl::ReadyForSparseIO(const net::CompletionCallback& callback) {
+int EntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   if (!sparse_.get())
     return net::OK;
 
-  backend_->background_queue()->ReadyForSparseIO(this, callback);
+  if (!background_queue_)
+    return net::ERR_UNEXPECTED;
+
+  background_queue_->ReadyForSparseIO(this, callback);
   return net::ERR_IO_PENDING;
 }
 
 // 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() {
   Log("~EntryImpl in");
+  if (!backend_) {
+    entry_.clear_modified();
+    node_.clear_modified();
+    return;
+  }
 
   // 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();
 
   // Remove this entry from the list of open entries.
   backend_->OnEntryDestroyBegin(entry_.address());
 
   if (doomed_) {
@@ skipping 27 matching lines @@
     }
   }
 
   Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this));
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL, NULL);
   backend_->OnEntryDestroyEnd();
 }
 
 // ------------------------------------------------------------------------
 
-int EntryImpl::InternalReadData(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback) {
+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_)
+    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);
   backend_->OnRead(buf_len);
 
@@ skipping 46 matching lines @@
   if (io_callback && completed)
     io_callback->Discard();
 
   if (io_callback)
     ReportIOTime(kReadAsync1, start_async);
 
   ReportIOTime(kRead, start);
   return (completed || callback.is_null()) ? buf_len : net::ERR_IO_PENDING;
 }
 
-int EntryImpl::InternalWriteData(
-    int index, int offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback, bool truncate) {
+int EntryImpl::InternalWriteData(int index, int offset,
+                                 IOBuffer* buf, int buf_len,
+                                 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_)
+    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;
     backend_->TooMuchStorageRequested(size);
     return net::ERR_FAILED;
@@ skipping 85 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_)
+    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 = (size + Addr::BlockSizeForFileType(file_type) - 1) /
                      Addr::BlockSizeForFileType(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_);
   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])
       files_[index] = NULL;  // Releases the object.
   } else {
     backend_->DeleteBlock(address, true);
   }
 }
 
 void EntryImpl::UpdateRank(bool modified) {
+  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_)
+    return NULL;
+
   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 <= kKeyFileIndex);
@@ skipping 251 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_);
   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;
     }
@@ skipping 21 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