Sparse IO: Allow failover to network in debug builds

net/http/mock_http_cache.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/http/mock_http_cache.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
@@ skipping 32 matching lines @@
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 struct MockDiskEntry::CallbackInfo {
   scoped_refptr<MockDiskEntry> entry;
   net::CompletionCallback callback;
   int result;
 };
 
-MockDiskEntry::MockDiskEntry()
-    : test_mode_(0), doomed_(false), sparse_(false),
-      fail_requests_(false), busy_(false), delayed_(false) {
-}
-
-MockDiskEntry::MockDiskEntry(const std::string& key)
+MockDiskEntry::MockDiskEntry(MockDiskCache* backend, const std::string& key)
     : key_(key), doomed_(false), sparse_(false),
-      fail_requests_(false), busy_(false), delayed_(false) {
+      fail_requests_(false), busy_(false), delayed_(false), backend_(backend) {
   test_mode_ = GetTestModeForEntry(key);
+  DCHECK(backend);
 }
 
 void MockDiskEntry::Doom() {
   doomed_ = true;
 }
 
 void MockDiskEntry::Close() {
   Release();
 }
 
@@ skipping 60 matching lines @@
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return net::ERR_IO_PENDING;
 }
 
 int MockDiskEntry::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                                   const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
+  backend_->NotifySparseIO();

[rvargas (doing something else), 2013/08/28 21:35:47]

This is slightly problematic because the contract doesn't require entries to be
closed before the cache (true for the backend and the http cache/transaction).
Do we really need the count?

[pasko, 2013/08/28 21:56:28]

I did not quite understand this sentence, can you clarify?
With checking entry state manually it may be not necessary. I'll take a look
tomorrow. Altogether having a count sounds consistent with the practices in
these mocks.

[rvargas (doing something else), 2013/08/28 22:33:40]

The thing is that it is possible (valid, and used) to keep working with an
HttpCache::Transaction and with a disk_cache::Entry after the HttpCache (and
backend) goes away. That doesn't mean that things are going to work fine, it
means that things should not crash... keeping this pointer here means we could
crash.

We can fix this behavior, but it seems simpler just to not have a count in the
first place, especially given that the whole thing is supposed to be somewhat
short lived.
The count makes the test more specific, that's true. But it is not really a bad
test without the count (as opposed to other counters on the mocks, which are
fundamental to most tests)

+  if (fail_sparse_requests_)
+    return net::ERR_NOT_IMPLEMENTED;
   if (!sparse_ || busy_)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (offset < 0)
     return net::ERR_FAILED;
 
   if (fail_requests_)
     return net::ERR_CACHE_READ_FAILURE;
 
   DCHECK(offset < kint32max);
   int real_offset = static_cast<int>(offset);
@@ skipping 10 matching lines @@
   CallbackLater(callback, num);
   busy_ = true;
   delayed_ = false;
   return net::ERR_IO_PENDING;
 }
 
 int MockDiskEntry::WriteSparseData(int64 offset, net::IOBuffer* buf,
                                    int buf_len,
                                    const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
+  backend_->NotifySparseIO();
+  if (fail_sparse_requests_)
+    return net::ERR_NOT_IMPLEMENTED;
   if (busy_)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (!sparse_) {
     if (data_[1].size())
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     sparse_ = true;
   }
   if (offset < 0)
     return net::ERR_FAILED;
   if (!buf_len)
@@ skipping 48 matching lines @@
     }
   }
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return count;
 
   CallbackLater(callback, count);
   return net::ERR_IO_PENDING;
 }
 
 bool MockDiskEntry::CouldBeSparse() const {
+  backend_->NotifySparseIO();
+  if (fail_sparse_requests_)
+    return false;
   return sparse_;
 }
 
 void MockDiskEntry::CancelSparseIO() {
+  backend_->NotifySparseIO();
   cancel_ = true;
 }
 
 int MockDiskEntry::ReadyForSparseIO(const net::CompletionCallback& callback) {
+  backend_->NotifySparseIO();
+  if (fail_sparse_requests_)
+    return net::ERR_NOT_IMPLEMENTED;
   if (!cancel_)
     return net::OK;
 
   cancel_ = false;
   DCHECK(!callback.is_null());
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
     return net::OK;
 
   // The pending operation is already in the message loop (and hopefully
   // already in the second pass).  Just notify the caller that it finished.
@@ skipping 67 matching lines @@
   }
 }
 
 // Statics.
 bool MockDiskEntry::cancel_ = false;
 bool MockDiskEntry::ignore_callbacks_ = false;
 
 //-----------------------------------------------------------------------------
 
 MockDiskCache::MockDiskCache()
-    : open_count_(0), create_count_(0), fail_requests_(false),
-      soft_failures_(false), double_create_check_(true) {
+    : open_count_(0), create_count_(0), sparse_count_(0), fail_requests_(false),
+      soft_failures_(false), double_create_check_(true),
+      fail_sparse_requests_(false) {
 }
 
 MockDiskCache::~MockDiskCache() {
   ReleaseAll();
 }
 
 net::CacheType MockDiskCache::GetCacheType() const {
   return net::DISK_CACHE;
 }
 
@@ skipping 46 matching lines @@
         NOTREACHED();
       else
         return net::ERR_CACHE_CREATE_FAILURE;
     }
     it->second->Release();
     entries_.erase(it);
   }
 
   create_count_++;
 
-  MockDiskEntry* new_entry = new MockDiskEntry(key);
+  MockDiskEntry* new_entry = new MockDiskEntry(this, key);
 
   new_entry->AddRef();
   entries_[key] = new_entry;
 
   new_entry->AddRef();
   *entry = new_entry;
 
   if (soft_failures_)
     new_entry->set_fail_requests();
 
+  if (fail_sparse_requests_)
+    new_entry->set_fail_sparse_requests();
+
   if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
     return net::OK;
 
   CallbackLater(callback, net::OK);
   return net::ERR_IO_PENDING;
 }
 
 int MockDiskCache::DoomEntry(const std::string& key,
                              const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
@@ skipping 186 matching lines @@
 void MockBlockingBackendFactory::FinishCreation() {
   block_ = false;
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     net::CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }