Ignore disk cache for concurrent byte range requests to a single resource, to prevent stalling.

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 825 matching lines @@
     // Downgrade to UPDATE if the request has been externally conditionalized.
     if (external_validation_.initialized) {
       if (mode_ & WRITE) {
         // Strip off the READ_DATA bit (and maybe add back a READ_META bit
         // in case READ was off).
         mode_ = UPDATE;
       } else {
         mode_ = NONE;
       }
     }
+
+    // If we're already writing to an active entry with this key and it is
+    // a range request, we want to switch to pass-through mode. This
+    // eliminates a long-running issue (crbug.com/31014) where two of the same
+    // video resource could not be played back simultaneously due to one locking
+    // the cache entry until the entire video was downloaded.
+    //
+    // This is not an ideal solution, as we are now ignoring the cache entirely
+    // for all range requests to a resource beyond the first. This is however a
+    // much more succinct solution than the alternatives, which would require
+    // somewhat significant changes to the http caching logic.
+    // TODO(rileya): Support simultaneous transactions on sparse cache entries,
+    // and remove this hack.

[scherkus (not reviewing), 2014/04/10 18:26:06]

if the plan is to close the original bug, then I'd recommending finding an
existing bug / filing a new bug we can link to

[rileya (GONE FROM CHROMIUM), 2014/04/10 19:24:51]

Sounds good, filed crbug.com/362215.

+    if (ActiveEntry* entry = cache_->FindActiveEntry(cache_key_)) {
+      if (partial_ && entry->writer && entry->writer->range_requested_)
+        mode_ = NONE;
+    }
   }
 
   // Use PUT and DELETE only to invalidate existing stored entries.
   if ((request_->method == "PUT" || request_->method == "DELETE") &&
       mode_ != READ_WRITE && mode_ != WRITE) {
     mode_ = NONE;
   }
 
   // If must use cache, then we must fail.  This can happen for back/forward
   // navigations to a page generated via a form post.
@@ skipping 1664 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net