Disk Cache: Implement GetAvailableRange for the regular disk cache....

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/string_util.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
@@ skipping 53 matching lines @@
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We only support up to 64 GB.
   if (offset + buf_len >= 0x1000000000LL)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   DCHECK(!user_buf_);
   DCHECK(!user_callback_);
 
+  if (!buf && (op == kReadOperation || op == kWriteOperation))
+    return 0;
+
   // Copy the operation parameters.
   operation_ = op;
   offset_ = offset;
-  user_buf_ = new net::ReusedIOBuffer(buf, buf_len);
+  user_buf_ = buf ? new net::ReusedIOBuffer(buf, buf_len) : NULL;
   buf_len_ = buf_len;
+  user_callback_ = callback;
 
   result_ = 0;
   pending_ = false;
   finished_ = false;
-  user_callback_ = callback;
 
   DoChildrenIO();
 
   if (!pending_) {
     // Everything was done synchronously.
     operation_ = kNoOperation;
     user_buf_ = NULL;
     user_callback_ = NULL;
     return result_;
   }
 
   return net::ERR_IO_PENDING;
 }
 
 int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) {
   DCHECK(init_);
-  NOTIMPLEMENTED();
-  return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+  // 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, NULL);
+  if (range_found_) {
+    *start = offset_;
+    return result;
+  }
+
+  *start = offset;
+  return result < 0 ? result : 0;  // Don't mask error codes to the caller.
 }
 
 // We are going to start using this entry to store sparse data, so we have to
 // initialize our control info.
 int SparseControl::CreateSparseEntry() {
   // TODO(rvargas): Set/check a flag in EntryStore.
 
   memset(&sparse_header_, 0, sizeof(sparse_header_));
   sparse_header_.signature = Time::Now().ToInternalValue();
   sparse_header_.magic = kIndexMagic;
@@ skipping 62 matching lines @@
   std::string key = GenerateChildKey();
   if (child_) {
     // Keep using the same child or open another one?.
     if (key == child_->GetKey())
       return true;
     CloseChild();
   }
 
   // Se if we are tracking this child.
   bool child_present = ChildPresent();
-  if (kReadOperation == operation_ && !child_present)
-    return false;
+  if (!child_present) {
+    if (kReadOperation == operation_)
+      return false;
+    if (kGetRangeOperation == operation_)
+      return true;
+  }
 
   if (!child_present || !entry_->backend_->OpenEntry(key, &child_)) {
     if (!entry_->backend_->CreateEntry(key, &child_)) {
       child_ = NULL;
       result_ = net::ERR_CACHE_READ_FAILURE;
       return false;
     }
     // Write signature.
     InitChildData();
     return true;
@@ skipping 70 matching lines @@
     DLOG(ERROR) << "Unable to save sparse map";
   }
 }
 
 bool SparseControl::VerifyRange() {
   DCHECK_GE(result_, 0);
 
   child_offset_ = static_cast<int>(offset_) & 0xfffff;
   child_len_ = std::min(buf_len_, 0x100000 - child_offset_);
 
-  // We can write to anywhere in this child.
+  // We can write to (or get info from) anywhere in this child.
   if (operation_ != kReadOperation)
     return true;
 
   // Check that there are no holes in this range.
   int last_bit = (child_offset_ + child_len_ + 1023) >> 10;
   int start = child_offset_ >> 10;
   if (child_map_.FindNextBit(&start, last_bit, false)) {
     // Something is not here.
     if (start == child_offset_ >> 10)
       return false;
@@ skipping 47 matching lines @@
     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 = user_callback_ ? &child_callback_ : NULL;
 
   int rv;
-  if (kReadOperation == operation_) {
-    rv = child_->ReadData(kSparseData, child_offset_, user_buf_, child_len_,
-                          callback);
-  } else {
-    DCHECK(kWriteOperation == operation_);
-    rv = child_->WriteData(kSparseData, child_offset_, user_buf_, child_len_,
-                           callback, false);
+  switch (operation_) {
+    case kReadOperation:
+      rv = child_->ReadData(kSparseData, child_offset_, user_buf_, child_len_,
+                            callback);
+      break;
+    case kWriteOperation:
+      rv = child_->WriteData(kSparseData, child_offset_, user_buf_, child_len_,
+                             callback, false);
+      break;
+    case kGetRangeOperation:
+      rv = DoGetAvailableRange();
+      break;
+    default:
+      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();
     }
     return false;
   }
 
   DoChildIOCompleted(rv);
   return true;
 }
 
+int SparseControl::DoGetAvailableRange() {
+  if (!child_)
+    return child_len_;  // Move on to the next child.
+
+  // Check that there are no holes in this range.
+  int last_bit = (child_offset_ + child_len_ + 1023) >> 10;
+  int start = child_offset_ >> 10;
+  int bits_found = child_map_.FindBits(&start, last_bit, true);
+
+  if (!bits_found)
+    return child_len_;
+
+  // We are done. Just break the loop and reset result_ to our real result.
+  range_found_ = true;
+  int empty_start = (start << 10) - child_offset_;
+  result_ = std::min(bits_found << 10, child_len_ - empty_start);
+  if (empty_start)
+    offset_ += empty_start;
+
+  buf_len_ = 0;
+  return 0;
+}
+
 void SparseControl::DoChildIOCompleted(int result) {
   if (result < 0) {
     // We fail the whole operation if we encounter an error.
     result_ = result;
     return;
   }
 
   UpdateRange(result);
 
   result_ += result;
   offset_ += result;
   buf_len_ -= result;
 
   // We'll be reusing the user provided buffer for the next chunk.
-  if (buf_len_)
+  if (buf_len_ && user_buf_)
     user_buf_->SetOffset(result_);
 }
 
 void SparseControl::OnChildIOCompleted(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
   DoChildIOCompleted(result);
 
   // 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_);
 }
 
 }  // namespace disk_cache