Disk cache: Add a method to cancel pending sparse operations....

net/disk_cache/sparse_control.cc

 // Copyright (c) 2009 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/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 174 matching lines @@
   // Copy the operation parameters.
   operation_ = op;
   offset_ = offset;
   user_buf_ = buf ? new net::ReusedIOBuffer(buf, buf_len) : NULL;
   buf_len_ = buf_len;
   user_callback_ = callback;
 
   result_ = 0;
   pending_ = false;
   finished_ = false;
+  abort_ = false;
 
   DoChildrenIO();
 
   if (!pending_) {
     // Everything was done synchronously.
     operation_ = kNoOperation;
     user_buf_ = NULL;
     user_callback_ = NULL;
     return result_;
   }
@@ skipping 14 matching lines @@
   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(net::CompletionCallback* completion_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(completion_callback);
+  return net::ERR_IO_PENDING;
+}
+
 // Static
 void SparseControl::DeleteChildren(EntryImpl* entry) {
   DCHECK(entry->GetEntryFlags() & PARENT_ENTRY);
   int data_len = entry->GetDataSize(kSparseIndex);
   if (data_len < static_cast<int>(sizeof(SparseData)) ||
       entry->GetDataSize(kSparseData))
     return;
 
   int map_len = data_len - sizeof(SparseHeader);
   if (map_len > kMaxMapSize || map_len % 4)
@@ skipping 355 matching lines @@
       NOTREACHED();
   }
 
   if (rv == net::ERR_IO_PENDING) {
     if (!pending_) {
       pending_ = true;
       // The child will protect himself against closing the entry while IO is in
       // progress. However, this entry can still be closed, and that would not
       // be a good thing for us, so we increase the refcount until we're
       // finished doing sparse stuff.
-      entry_->AddRef();
+      entry_->AddRef();  // Balanced in DoUserCallback.
     }
     return false;
   }
   if (!rv)
     return false;
 
   DoChildIOCompleted(rv);
   return true;
 }
 
@@ skipping 59 matching lines @@
 
   // We'll be reusing the user provided buffer for the next chunk.
   if (buf_len_ && user_buf_)
     user_buf_->SetOffset(result_);
 }
 
 void SparseControl::OnChildIOCompleted(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
   DoChildIOCompleted(result);
 
+  if (abort_) {
+    // We'll return the current result of the operation, which may be less than
+    // the bytes to read or write, but the user cancelled the operation.
+    abort_ = false;
+    DoUserCallback();
+    return DoAbortCallbacks();
+  }
+
   // 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_);
   net::CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
   user_buf_ = NULL;
   pending_ = false;
   operation_ = kNoOperation;
   entry_->Release();  // Don't touch object after this line.
   c->Run(result_);
 }
 
+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* c = abort_callbacks_[i];
+    if (i == abort_callbacks_.size() - 1)
+      abort_callbacks_.clear();
+
+    entry_->Release();  // Don't touch object after this line.
+    c->Run(net::OK);
+  }
+}
+
 }  // namespace disk_cache