Fixed playing video in component extensions.

net/url_request/url_request_simple_job.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/url_request/url_request_simple_job.h"
 
+#include <vector>
+
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_util.h"
 #include "net/url_request/url_request_status.h"
 
 namespace net {
 
 URLRequestSimpleJob::URLRequestSimpleJob(
     URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestJob(request, network_delegate),
       data_offset_(0),
       weak_factory_(this) {}
 
@@ skipping 13 matching lines @@
 bool URLRequestSimpleJob::GetCharset(std::string* charset) {
   *charset = charset_;
   return true;
 }
 
 URLRequestSimpleJob::~URLRequestSimpleJob() {}
 
 bool URLRequestSimpleJob::ReadRawData(IOBuffer* buf, int buf_size,
                                       int* bytes_read) {
   DCHECK(bytes_read);
-  int remaining = static_cast<int>(data_.size()) - data_offset_;
+  int remaining = byte_range_.last_byte_position() - data_offset_ + 1;
   if (buf_size > remaining)
     buf_size = remaining;
   memcpy(buf->data(), data_.data() + data_offset_, buf_size);
   data_offset_ += buf_size;
   *bytes_read = buf_size;
   return true;
 }
 
+void URLRequestSimpleJob::SetExtraRequestHeaders(
+    const HttpRequestHeaders& headers) {
+  std::string range_header;
+  if (headers.GetHeader(HttpRequestHeaders::kRange, &range_header)) {
+    std::vector<HttpByteRange> ranges;
+    if (HttpUtil::ParseRangeHeader(range_header, &ranges)) {

[mmenke, 2013/12/17 17:10:15]

Should we fail if we have a range header we can't parse?  I don't feel strongly
about it, but may be a little more consistent.

+      if (ranges.size() == 1) {
+        byte_range_ = ranges[0];
+      } else {
+        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                                    ERR_REQUEST_RANGE_NOT_SATISFIABLE));

[mmenke, 2013/12/17 17:10:15]

Calling NotifyDone before Start() seems like a bad idea to me, particularly
since Start() is still being called, and you're relying on NotifyDone to post a
single async message that gets handled before StartAsync is called.

I suggest just copying the entire headers in this function, and parsing them in
StartAsync.  Alternatively, could parse the headers here, and just cache if
there's an error and handle it in StartAsync() to save a little memory, but I
don't think it's a big deal.

[kirr, 2013/12/18 08:03:30]

It seems you are right.
But all URLRequestJobs with range request do the same thing.
See StreamURLRequestJob, FileSystemURLRequestJob etc.

Should we implement the different behaviour here?

On 2013/12/17 17:10:15, mmenke wrote:

[mmenke, 2013/12/18 15:40:31]

Thanks for pointing that out!

I think conceptually, it's a little odd calling being NotifyDone before you've
even started, and I'm a bit reluctant to add another contract.  However, it is
convenient in practice, and it looks like we already have 6 classes with this
code, or something much like it, copied and pasted, so I think the way to go is
to explicitly support this use case.

I'm not comfortable landing the CL until we have code preventing us from calling
Start when this happens.  Fortunately, that's a tiny CL, though it should have a
unit test.  I'll go ahead and put together the CL to do that myself, today or
tomorrow.  Once landed, I'll fine with this code.


On 2013/12/18 08:03:30, kirr wrote:

+      }
+    }
+  }
+}
+
 void URLRequestSimpleJob::StartAsync() {
   if (!request_)
     return;
 
   int result = GetData(&mime_type_, &charset_, &data_,
                        base::Bind(&URLRequestSimpleJob::OnGetDataCompleted,
                                   weak_factory_.GetWeakPtr()));
   if (result != ERR_IO_PENDING)
     OnGetDataCompleted(result);
 }
 
 void URLRequestSimpleJob::OnGetDataCompleted(int result) {
   if (result == OK) {
     // Notify that the headers are complete
+    if (!byte_range_.ComputeBounds(data_.size())) {
+      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
+                 ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+      return;
+    }
+
+    data_offset_ = byte_range_.first_byte_position();
+    int remaining_bytes = byte_range_.last_byte_position() -
+        byte_range_.first_byte_position() + 1;
+    set_expected_content_size(remaining_bytes);
     NotifyHeadersComplete();
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 }  // namespace net