make multibuffer work with layout tests

media/blink/resource_multibuffer_data_provider.cc

 // Copyright 2015 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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 14 matching lines @@
 using blink::WebURLLoader;
 using blink::WebURLLoaderOptions;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 namespace media {
 
 // The number of milliseconds to wait before retrying a failed load.
 const int kLoaderFailedRetryDelayMs = 250;
 
+// The number of milliseconds to wait before retrying when the server
+// decides to not give us all the data at once.
+const int kLoaderPartialRetryDelayMs = 25;
+
 const int kHttpOK = 200;
 const int kHttpPartialContent = 206;
 const int kHttpRangeNotSatisfiable = 416;
 const int kMaxRetries = 3;
 
 ResourceMultiBufferDataProvider::ResourceMultiBufferDataProvider(
     UrlData* url_data,
     MultiBufferBlockId pos)
     : pos_(pos),
       url_data_(url_data),
       retries_(0),
       cors_mode_(url_data->cors_mode()),
       origin_(url_data->url().GetOrigin()),
       weak_factory_(this) {
   DCHECK(url_data_) << " pos = " << pos;
   DCHECK_GE(pos, 0);
 }
 
 void ResourceMultiBufferDataProvider::Start() {
-  // In the case of a re-start, throw away any half-finished blocks.
-  fifo_.clear();
   // Prepare the request.
   WebURLRequest request(url_data_->url());
   // TODO(mkwst): Split this into video/audio.
   request.setRequestContext(WebURLRequest::RequestContextVideo);
 
+  DVLOG(1) << __FUNCTION__ << " @ " << byte_pos();
+  if (url_data_->length() > 0) {
+    DCHECK_LT(byte_pos(), url_data_->length()) << " " << url_data_->url();
+  }
+
   request.setHTTPHeaderField(
       WebString::fromUTF8(net::HttpRequestHeaders::kRange),
       WebString::fromUTF8(
           net::HttpByteRange::RightUnbounded(byte_pos()).GetHeaderValue()));
 
   url_data_->frame()->setReferrerForRequest(request, blink::WebURL());
 
   // Disable compression, compression for audio/video doesn't make sense...
   request.setHTTPHeaderField(
       WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding),
@@ skipping 64 matching lines @@
 void ResourceMultiBufferDataProvider::willFollowRedirect(
     WebURLLoader* loader,
     WebURLRequest& newRequest,
     const WebURLResponse& redirectResponse) {
   redirects_to_ = newRequest.url();
   url_data_->set_valid_until(base::Time::Now() +
                              GetCacheValidUntil(redirectResponse));
 
   // This test is vital for security!
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED) {
+    // We allow the redirect if the origin is the same.
     if (origin_ != redirects_to_.GetOrigin()) {
+      // We also allow the redirect if we don't have any data in the
+      // cache, as that means that no dangerous data mixing can occur.
+      if (url_data_->multibuffer()->map().empty() && fifo_.empty())
+        return;
+
       url_data_->Fail();
     }
   }
 }
 
 void ResourceMultiBufferDataProvider::didSendData(
     WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   NOTIMPLEMENTED();
@@ skipping 195 matching lines @@
   // If we didn't know the |instance_size_| we do now.
   int64_t size = byte_pos();
   if (!fifo_.empty())
     size += fifo_.back()->data_size();
 
   // This request reports something smaller than what we've seen in the past,
   // Maybe it's transient error?
   if (url_data_->length() != kPositionNotSpecified &&
       size < url_data_->length()) {
     if (retries_ < kMaxRetries) {
-      fifo_.clear();
+      DVLOG(1) << " Partial data received.... @ pos = " << size;
       retries_++;
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE, base::Bind(&ResourceMultiBufferDataProvider::Start,
                                 weak_factory_.GetWeakPtr()),
-          base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs));
+          base::TimeDelta::FromMilliseconds(kLoaderPartialRetryDelayMs));
       return;
     } else {
       scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
       url_data_->Fail();
       return;
     }
   }
 
   url_data_->set_length(size);
   fifo_.push_back(DataBuffer::CreateEOSBuffer());
 
   DCHECK(Available());
   url_data_->multibuffer()->OnDataProviderEvent(this);
 
   // Beware, this object might be deleted here.
 }
 
 void ResourceMultiBufferDataProvider::didFail(WebURLLoader* loader,
                                               const WebURLError& error) {
   DVLOG(1) << "didFail: reason=" << error.reason
            << ", isCancellation=" << error.isCancellation
            << ", domain=" << error.domain.utf8().data()
            << ", localizedDescription="
            << error.localizedDescription.utf8().data();
   DCHECK(active_loader_.get());
 
-  if (retries_ < kMaxRetries) {
+  if (retries_ < kMaxRetries && pos_ != 0) {
     retries_++;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&ResourceMultiBufferDataProvider::Start,
                               weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs));
   } else {
     // We don't need to continue loading after failure.
     //
     // Keep it alive until we exit this method so that |error| remains valid.
     scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
@@ skipping 38 matching lines @@
       (*instance_size != kPositionNotSpecified &&
        *last_byte_position >= *instance_size)) {
     return false;
   }
 
   return true;
 }
 
 int64_t ResourceMultiBufferDataProvider::byte_pos() const {
   int64_t ret = pos_;
-  return ret << url_data_->multibuffer()->block_size_shift();
+  ret += fifo_.size();
+  ret = ret << url_data_->multibuffer()->block_size_shift();
+  if (!fifo_.empty()) {
+    ret += fifo_.back()->data_size() - block_size();
+  }
+  return ret;
 }
 
 int64_t ResourceMultiBufferDataProvider::block_size() const {
   int64_t ret = 1;
   return ret << url_data_->multibuffer()->block_size_shift();
 }
 
 bool ResourceMultiBufferDataProvider::VerifyPartialResponse(
     const WebURLResponse& response) {
   int64 first_byte_position, last_byte_position, instance_size;
   if (!ParseContentRange(response.httpHeaderField("Content-Range").utf8(),
                          &first_byte_position, &last_byte_position,
                          &instance_size)) {
     return false;
   }
 
   if (url_data_->length() == kPositionNotSpecified) {
     url_data_->set_length(instance_size);
   }
 
   if (byte_pos() != first_byte_position) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace media