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

net/disk_cache/sparse_control.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/sparse_control.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 211 matching lines @@
 bool SparseControl::CouldBeSparse() const {
   DCHECK(!init_);
 
   if (entry_->GetDataSize(kSparseData))
     return false;
 
   // We don't verify the data, just see if it could be there.
   return (entry_->GetDataSize(kSparseIndex) != 0);
 }
 
-int SparseControl::StartIO(
-    SparseOperation op, int64 offset, net::IOBuffer* buf, int buf_len,
-    const net::CompletionCallback& callback) {
+int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
+                           int buf_len, const CompletionCallback& callback) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We only support up to 64 GB.
   if (offset + buf_len >= 0x1000000000LL || offset + buf_len < 0)
@@ skipping 38 matching lines @@
 int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   DCHECK(start);
 
   range_found_ = false;
   int result = StartIO(
-      kGetRangeOperation, offset, NULL, len, net::CompletionCallback());
+      kGetRangeOperation, offset, NULL, len, CompletionCallback());
   if (range_found_) {
     *start = offset_;
     return result;
   }
 
   // This is a failure. We want to return a valid start value in any case.
   *start = offset;
   return result < 0 ? result : 0;  // Don't mask error codes to the caller.
 }
 
 void SparseControl::CancelIO() {
   if (operation_ == kNoOperation)
     return;
   abort_ = true;
 }
 
-int SparseControl::ReadyToUse(const net::CompletionCallback& callback) {
+int SparseControl::ReadyToUse(const CompletionCallback& callback) {
   if (!abort_)
     return net::OK;
 
   // We'll grab another reference to keep this object alive because we just have
   // one extra reference due to the pending IO operation itself, but we'll
   // release that one before invoking user_callback_.
   entry_->AddRef();  // Balanced in DoAbortCallbacks.
   abort_callbacks_.push_back(callback);
   return net::ERR_IO_PENDING;
 }
@@ skipping 42 matching lines @@
   sparse_header_.signature = Time::Now().ToInternalValue();
   sparse_header_.magic = kIndexMagic;
   sparse_header_.parent_key_len = entry_->GetKey().size();
   children_map_.Resize(kNumSparseBits, true);
 
   // Save the header. The bitmap is saved in the destructor.
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
   int rv = entry_->WriteData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), net::CompletionCallback(),
+      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback(),
       false);
   if (rv != sizeof(sparse_header_)) {
     DLOG(ERROR) << "Unable to save sparse_header_";
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   }
 
   entry_->SetEntryFlags(PARENT_ENTRY);
   return net::OK;
 }
 
@@ skipping 11 matching lines @@
   // Dont't go over board with the bitmap. 8 KB gives us offsets up to 64 GB.
   int map_len = data_len - sizeof(sparse_header_);
   if (map_len > kMaxMapSize || map_len % 4)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
   // Read header.
   int rv = entry_->ReadData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), net::CompletionCallback());
+      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback());
   if (rv != static_cast<int>(sizeof(sparse_header_)))
     return net::ERR_CACHE_READ_FAILURE;
 
   // The real validation should be performed by the caller. This is just to
   // double check.
   if (sparse_header_.magic != kIndexMagic ||
       sparse_header_.parent_key_len !=
           static_cast<int>(entry_->GetKey().size()))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   // Read the actual bitmap.
   buf = new net::IOBuffer(map_len);
   rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf, map_len,
-                        net::CompletionCallback());
+                        CompletionCallback());
   if (rv != map_len)
     return net::ERR_CACHE_READ_FAILURE;
 
   // Grow the bitmap to the current size and copy the bits.
   children_map_.Resize(map_len * 8, false);
   children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len);
   return net::OK;
 }
 
 bool SparseControl::OpenChild() {
   DCHECK_GE(result_, 0);
 
   std::string key = GenerateChildKey();
   if (child_) {
     // Keep using the same child or open another one?.
     if (key == child_->GetKey())
       return true;
     CloseChild();
   }
 
   // See if we are tracking this child.
   if (!ChildPresent())
     return ContinueWithoutChild(key);
 
+  if (!entry_->backend_)
+    return false;
+
   child_ = entry_->backend_->OpenEntryImpl(key);
   if (!child_)
     return ContinueWithoutChild(key);
 
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   if (!(CHILD_ENTRY & child->GetEntryFlags()) ||
       child->GetDataSize(kSparseIndex) <
           static_cast<int>(sizeof(child_data_)))
     return KillChildAndContinue(key, false);
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Read signature.
-  int rv = child_->ReadData(
-      kSparseIndex, 0, buf, sizeof(child_data_), net::CompletionCallback());
+  int rv = child_->ReadData(kSparseIndex, 0, buf, sizeof(child_data_),
+                            CompletionCallback());
   if (rv != sizeof(child_data_))
     return KillChildAndContinue(key, true);  // This is a fatal failure.
 
   if (child_data_.header.signature != sparse_header_.signature ||
       child_data_.header.magic != kIndexMagic)
     return KillChildAndContinue(key, false);
 
   if (child_data_.header.last_block_len < 0 ||
       child_data_.header.last_block_len > kBlockSize) {
     // Make sure these values are always within range.
     child_data_.header.last_block_len = 0;
     child_data_.header.last_block = -1;
   }
 
   return true;
 }
 
 void SparseControl::CloseChild() {
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Save the allocation bitmap before closing the child entry.
-  int rv = child_->WriteData(
-      kSparseIndex, 0, buf, sizeof(child_data_), net::CompletionCallback(),
+  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
+                             CompletionCallback(),
       false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   child_->Release();
   child_ = NULL;
 }
 
 std::string SparseControl::GenerateChildKey() {
   return GenerateChildName(entry_->GetKey(), sparse_header_.signature,
                            offset_ >> 20);
@@ skipping 12 matching lines @@
   return ContinueWithoutChild(key);
 }
 
 // We were not able to open this child; see what we can do.
 bool SparseControl::ContinueWithoutChild(const std::string& key) {
   if (kReadOperation == operation_)
     return false;
   if (kGetRangeOperation == operation_)
     return true;
 
+  if (!entry_->backend_)
+    return false;
+
   child_ = entry_->backend_->CreateEntryImpl(key);
   if (!child_) {
     child_ = NULL;
     result_ = net::ERR_CACHE_READ_FAILURE;
     return false;
   }
   // Write signature.
   InitChildData();
   return true;
 }
@@ skipping 14 matching lines @@
     children_map_.Resize(Bitmap::RequiredArraySize(child_bit + 1) * 32, true);
 
   children_map_.Set(child_bit, value);
 }
 
 void SparseControl::WriteSparseData() {
   scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer(
       reinterpret_cast<const char*>(children_map_.GetMap())));
 
   int len = children_map_.ArraySize() * 4;
-  int rv = entry_->WriteData(
-      kSparseIndex, sizeof(sparse_header_), buf, len, net::CompletionCallback(),
-      false);
+  int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf, len,
+                             CompletionCallback(), false);
   if (rv != len) {
     DLOG(ERROR) << "Unable to save sparse map";
   }
 }
 
 bool SparseControl::VerifyRange() {
   DCHECK_GE(result_, 0);
 
   child_offset_ = static_cast<int>(offset_) & (kMaxEntrySize - 1);
   child_len_ = std::min(buf_len_, kMaxEntrySize - child_offset_);
@@ skipping 82 matching lines @@
   // We know the real type of child_.
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   child->SetEntryFlags(CHILD_ENTRY);
 
   memset(&child_data_, 0, sizeof(child_data_));
   child_data_.header = sparse_header_;
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
-  int rv = child_->WriteData(
-      kSparseIndex, 0, buf, sizeof(child_data_), net::CompletionCallback(),
-      false);
+  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
+                             CompletionCallback(), false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   SetChildBit(true);
 }
 
 void SparseControl::DoChildrenIO() {
   while (DoChildIO()) continue;
 
   // Range operations are finished synchronously, often without setting
   // |finished_| to true.
@@ skipping 20 matching lines @@
     return false;
 
   if (!OpenChild())
     return false;
 
   if (!VerifyRange())
     return false;
 
   // We have more work to do. Let's not trigger a callback to the caller.
   finished_ = false;
-  net::CompletionCallback callback;
+  CompletionCallback callback;
   if (!user_callback_.is_null()) {
     callback =
         base::Bind(&SparseControl::OnChildIOCompleted, base::Unretained(this));
   }
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
       if (entry_->net_log().IsLoggingAllEvents()) {
         entry_->net_log().BeginEvent(
@@ skipping 129 matching lines @@
     return;
   }
 
   // We are running a callback from the message loop. It's time to restart what
   // we were doing before.
   DoChildrenIO();
 }
 
 void SparseControl::DoUserCallback() {
   DCHECK(!user_callback_.is_null());
-  net::CompletionCallback cb = user_callback_;
+  CompletionCallback cb = user_callback_;
   user_callback_.Reset();
   user_buf_ = NULL;
   pending_ = false;
   operation_ = kNoOperation;
   int rv = result_;
   entry_->Release();  // Don't touch object after this line.
   cb.Run(rv);
 }
 
 void SparseControl::DoAbortCallbacks() {
   for (size_t i = 0; i < abort_callbacks_.size(); i++) {
     // Releasing all references to entry_ may result in the destruction of this
     // object so we should not be touching it after the last Release().
-    net::CompletionCallback cb = abort_callbacks_[i];
+    CompletionCallback cb = abort_callbacks_[i];
     if (i == abort_callbacks_.size() - 1)
       abort_callbacks_.clear();
 
     entry_->Release();  // Don't touch object after this line.
     cb.Run(net::OK);
   }
 }
 
 }  // namespace disk_cache