media: Allow suspend on HTTP 200 videos

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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 269 matching lines @@
 
     reasons >>= 1;
     ++shift;
   }
 
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
   int64_t content_length = response.ExpectedContentLength();
   bool end_of_file = false;
   bool do_fail = false;
+  bytes_to_discard_ = 0;
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
   if (destination_url_data->url().SchemeIsHTTPOrHTTPS()) {
     bool partial_response = (response.HttpStatusCode() == kHttpPartialContent);
     bool ok_response = (response.HttpStatusCode() == kHttpOK);
 
     // Check to see whether the server supports byte ranges.
     std::string accept_ranges =
         response.HttpHeaderField("Accept-Ranges").Utf8();
     if (accept_ranges.find("bytes") != std::string::npos)
       destination_url_data->set_range_supported();
 
     // If we have verified the partial response and it is correct.
     // It's also possible for a server to support range requests
     // without advertising "Accept-Ranges: bytes".
     if (partial_response &&
         VerifyPartialResponse(response, destination_url_data)) {
       destination_url_data->set_range_supported();
-    } else if (ok_response && pos_ == 0) {
+    } else if (ok_response) {
       // We accept a 200 response for a Range:0- request, trusting the
       // Accept-Ranges header, because Apache thinks that's a reasonable thing
       // to return.
       destination_url_data->set_length(content_length);
+      bytes_to_discard_ = byte_pos();
     } else if (response.HttpStatusCode() == kHttpRangeNotSatisfiable) {
       // Unsatisfiable range
       // Really, we should never request a range that doesn't exist, but
       // if we do, let's handle it in a sane way.
       // Note, we can't just call OnDataProviderEvent() here, because
       // url_data_ hasn't been updated to the final destination yet.
       end_of_file = true;
     } else {
       active_loader_ = nullptr;
       // Can't call fail until readers have been migrated to the new
@@ skipping 53 matching lines @@
   }
 }
 
 void ResourceMultiBufferDataProvider::DidReceiveData(const char* data,
                                                      int data_length) {
   DVLOG(1) << "didReceiveData: " << data_length << " bytes";
   DCHECK(!Available());
   DCHECK(active_loader_);
   DCHECK_GT(data_length, 0);
 
+  if (bytes_to_discard_) {
+    uint64_t tmp = std::min<uint64_t>(bytes_to_discard_, data_length);
+    data_length -= tmp;
+    data += tmp;
+    bytes_to_discard_ -= tmp;
+    if (data_length == 0)
+      return;
+  }
+
   // When we receive data, we allow more retries.
   retries_ = 0;
 
   while (data_length) {
     if (fifo_.empty() || fifo_.back()->data_size() == block_size()) {
       fifo_.push_back(new DataBuffer(block_size()));
       fifo_.back()->set_data_size(0);
     }
     int last_block_size = fifo_.back()->data_size();
     int to_append = std::min<int>(data_length, block_size() - last_block_size);
@@ skipping 155 matching lines @@
   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) {
+  if (first_byte_position > byte_pos()) {
     return false;
   }
+  if (last_byte_position + 1 < byte_pos()) {
+    return false;
+  }
+  bytes_to_discard_ = byte_pos() - first_byte_position;
 
   return true;
 }
 
 }  // namespace media