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)
     : key_(key), doomed_(false), sparse_(false),
-      fail_requests_(false), busy_(false), delayed_(false) {
+      fail_requests_(false), fail_sparse_requests_(false), busy_(false),
+      delayed_(false) {
   test_mode_ = GetTestModeForEntry(key);
 }
 
 void MockDiskEntry::Doom() {
   doomed_ = true;
 }
 
 void MockDiskEntry::Close() {
   Release();
 }
@@ skipping 61 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());
+  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());
+  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 {
+  if (fail_sparse_requests_)
+    return false;
   return sparse_;
 }
 
 void MockDiskEntry::CancelSparseIO() {
   cancel_ = true;
 }
 
 int MockDiskEntry::ReadyForSparseIO(const net::CompletionCallback& callback) {
+  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 68 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) {
+      soft_failures_(false), double_create_check_(true),
+      fail_sparse_requests_(false) {
 }
 
 MockDiskCache::~MockDiskCache() {
   ReleaseAll();
 }
 
 net::CacheType MockDiskCache::GetCacheType() const {
   return net::DISK_CACHE;
 }
 
@@ skipping 57 matching lines @@
 
   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.
   }
 }