Sparse IO: Allow failover to network in debug builds

net/http/http_cache_transaction.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/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1512 matching lines @@
 
 int HttpCache::Transaction::DoCacheQueryData() {
   next_state_ = STATE_CACHE_QUERY_DATA_COMPLETE;
 
   // Balanced in DoCacheQueryDataComplete.
   return ResetCacheIOStart(
       entry_->disk_entry->ReadyForSparseIO(io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheQueryDataComplete(int result) {
+  if (result == ERR_NOT_IMPLEMENTED) {
+    // Send the network request if the backend does not support caching ranges.

[gavinp, 2013/08/26 15:46:37]

Should we add a TODO here for after the simple cache supports ranges?

[pasko, 2013/08/27 17:22:13]

Done.

+    next_state_ = STATE_SEND_REQUEST;

[rvargas (doing something else), 2013/08/26 21:24:52]

This is most likely not enough. It basically means that the transaction is
moving forward to issue the request (as it stands right now) and when the
response is received we'll assume that the backend has sparse data or can deal
with it.

I suspect that either we have to go through DoRestartPartialRequest() (and
transition to mode_ = WRITE), or close the entry and transition to pass through
(mode_ = NONE) in case we want to spare the entry.

[pasko, 2013/08/27 17:22:13]

Thanks!

Doing DoRestartPartialRequest() is indeed cleaner (I did not know about it
before). This will restart the transaction overwriting the entry regardless of
the server response, which makes it easier to reason about the effect.

I tested this code with this JS code on both Android and Linux:
=== begin code ===
  var xhr = new XMLHttpRequest();
  xhr.open('GET', '/url.html', true);
  xhr.setRequestHeader('Range', 'bytes=0-1023');
  xhr.responseType = 'arraybuffer';
  xhr.onreadystatechange = function() {
    if (xhr.readyState == 4) {
      document.write("<h1>response1 received</h1>");
      var xhr2 = new XMLHttpRequest();
      xhr2.open('GET', '/url.html', true);
      xhr2.setRequestHeader('Range', 'bytes=0-1023');
      xhr2.responseType = 'arraybuffer';
      xhr2.onreadystatechange = function() {
        if (xhr2.readyState == 4) {
          document.write("<h1>response2 received</h1>");
        }
      }
      xhr2.send();
    }
  }
  xhr.send();
=== end code ===

The server does not return 206 though. But with the current fix I do not think
it is of any interest.

I am still wondering how I could test it with a unittest. Modifying the
MockDiskEntry to return NOT_IMPLEMENTED seems an overkill. Let me know if you
think otherwise or have alternative suggestions.

+    return OK;
+  }
   DCHECK_EQ(OK, result);
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   return ValidateEntryHeadersAndContinue();
 }
 
 int HttpCache::Transaction::DoCacheReadData() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
@@ skipping 1052 matching lines @@
 void HttpCache::Transaction::ResetNetworkTransaction() {
   DCHECK(!old_network_trans_load_timing_);
   DCHECK(network_trans_);
   LoadTimingInfo load_timing;
   if (network_trans_->GetLoadTimingInfo(&load_timing))
     old_network_trans_load_timing_.reset(new LoadTimingInfo(load_timing));
   network_trans_.reset();
 }
 
 }  // namespace net