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

net/disk_cache/in_flight_backend_io.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/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
     return ExecuteEntryOperation();
 
   ExecuteBackendOperation();
 }
 
 // Runs on the background thread.
 void BackendIO::OnIOComplete(int result) {
   DCHECK(IsEntryOperation());
   DCHECK_NE(result, net::ERR_IO_PENDING);
   result_ = result;
-  controller_->OnIOComplete(this);
+  NotifyController();
+}
+
+// Runs on the primary thread.
+void BackendIO::OnDone(bool cancel) {
+  if (IsEntryOperation()) {
+    CACHE_UMA(TIMES, "TotalIOTime", 0, ElapsedTime());
+  }
+
+  if (!ReturnsEntry())
+    return;
+
+  if (result() == net::OK) {
+    static_cast<EntryImpl*>(*entry_ptr_)->OnEntryCreated(backend_);
+    if (cancel)
+      (*entry_ptr_)->Close();
+  }
 }
 
 bool BackendIO::IsEntryOperation() {
   return operation_ > OP_MAX_BACKEND;
 }
 
 // Runs on the background thread.
 void BackendIO::ReferenceEntry() {
   entry_->AddRef();
 }
 
-base::TimeDelta BackendIO::ElapsedTime() const {
-  return base::TimeTicks::Now() - start_time_;
-}
-
 void BackendIO::Init() {
   operation_ = OP_INIT;
 }
 
 void BackendIO::OpenEntry(const std::string& key, Entry** entry) {
   operation_ = OP_OPEN;
   key_ = key;
   entry_ptr_ = entry;
 }
 
@@ skipping 118 matching lines @@
   entry_ = entry;
 }
 
 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
   operation_ = OP_IS_READY;
   entry_ = entry;
 }
 
 BackendIO::~BackendIO() {}
 
+bool BackendIO::ReturnsEntry() {
+  return (operation_ == OP_OPEN || operation_ == OP_CREATE ||
+          operation_ == OP_OPEN_NEXT || operation_ == OP_OPEN_PREV);
+}
+
+base::TimeDelta BackendIO::ElapsedTime() const {
+  return base::TimeTicks::Now() - start_time_;
+}
+
 // Runs on the background thread.
 void BackendIO::ExecuteBackendOperation() {
   switch (operation_) {
     case OP_INIT:
       result_ = backend_->SyncInit();
       break;
     case OP_OPEN:
       result_ = backend_->SyncOpenEntry(key_, entry_ptr_);
       break;
     case OP_CREATE:
@@ skipping 38 matching lines @@
       break;
     case OP_RUN_TASK:
       task_.Run();
       result_ = net::OK;
       break;
     default:
       NOTREACHED() << "Invalid Operation";
       result_ = net::ERR_UNEXPECTED;
   }
   DCHECK_NE(net::ERR_IO_PENDING, result_);
-  controller_->OnIOComplete(this);
+  NotifyController();
 }
 
 // Runs on the background thread.
 void BackendIO::ExecuteEntryOperation() {
   switch (operation_) {
     case OP_READ:
       result_ = entry_->ReadDataImpl(
           index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, base::Unretained(this)));
+          base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE:
       result_ = entry_->WriteDataImpl(
           index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, base::Unretained(this)),
+          base::Bind(&BackendIO::OnIOComplete, this),
           truncate_);
       break;
     case OP_READ_SPARSE:
       result_ = entry_->ReadSparseDataImpl(
           offset64_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, base::Unretained(this)));
+          base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE_SPARSE:
       result_ = entry_->WriteSparseDataImpl(
           offset64_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, base::Unretained(this)));
+          base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_GET_RANGE:
       result_ = entry_->GetAvailableRangeImpl(offset64_, buf_len_, start_);
       break;
     case OP_CANCEL_IO:
       entry_->CancelSparseIOImpl();
       result_ = net::OK;
       break;
     case OP_IS_READY:
       result_ = entry_->ReadyForSparseIOImpl(
-          base::Bind(&BackendIO::OnIOComplete, base::Unretained(this)));
+          base::Bind(&BackendIO::OnIOComplete, this));
       break;
     default:
       NOTREACHED() << "Invalid Operation";
       result_ = net::ERR_UNEXPECTED;
   }
   if (result_ != net::ERR_IO_PENDING)
-    controller_->OnIOComplete(this);
+    NotifyController();
 }
 
 InFlightBackendIO::InFlightBackendIO(BackendImpl* backend,
                     base::MessageLoopProxy* background_thread)
     : backend_(backend),
-      background_thread_(background_thread) {
+      background_thread_(background_thread),
+      ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
 }
 
 InFlightBackendIO::~InFlightBackendIO() {
 }
 
 void InFlightBackendIO::Init(const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->Init();
   PostOperation(operation);
 }
@@ skipping 151 matching lines @@
   PostOperation(operation);
 }
 
 void InFlightBackendIO::WaitForPendingIO() {
   InFlightIO::WaitForPendingIO();
 }
 
 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
                                             bool cancel) {
   BackendIO* op = static_cast<BackendIO*>(operation);
-
-  if (op->IsEntryOperation()) {
-    CACHE_UMA(TIMES, "TotalIOTime", 0, op->ElapsedTime());
-  }
+  op->OnDone(cancel);
 
   if (!op->callback().is_null() && (!cancel || op->IsEntryOperation()))
     op->callback().Run(op->result());
 }
 
 void InFlightBackendIO::PostOperation(BackendIO* operation) {
   background_thread_->PostTask(FROM_HERE,
       base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
+base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
+  return ptr_factory_.GetWeakPtr();
+}
+
 }  // namespace