Revert 68094 - Refactoring BufferedDataSource to work with WebURLLoader inste...

webkit/glue/media/buffered_data_source.cc

 // Copyright (c) 2010 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 "base/callback.h"
 #include "base/compiler_specific.h"
-#include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
-#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "media/base/filter_host.h"
 #include "media/base/media_format.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebKit.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebKitClient.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebString.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLError.h"
+#include "net/http/http_response_headers.h"
 #include "webkit/glue/media/buffered_data_source.h"
-#include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webmediaplayer_impl.h"
 
-using WebKit::WebFrame;
-using WebKit::WebString;
-using WebKit::WebURLError;
-using WebKit::WebURLLoader;
-using WebKit::WebURLRequest;
-using WebKit::WebURLResponse;
-using webkit_glue::MultipartResponseDelegate;
-
 namespace {
 
 const char kHttpScheme[] = "http";
 const char kHttpsScheme[] = "https";
 const char kDataScheme[] = "data";
 const int64 kPositionNotSpecified = -1;
 const int kHttpOK = 200;
 const int kHttpPartialContent = 206;
 
 // Define the number of bytes in a megabyte.
@@ skipping 33 matching lines @@
   return url.SchemeIs(kHttpScheme) || url.SchemeIs(kHttpsScheme);
 }
 
 bool IsDataProtocol(const GURL& url) {
   return url.SchemeIs(kDataScheme);
 }
 
 }  // namespace
 
 namespace webkit_glue {
-
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader
 BufferedResourceLoader::BufferedResourceLoader(
+    webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory,
     const GURL& url,
     int64 first_byte_position,
     int64 last_byte_position)
     : buffer_(new media::SeekableBuffer(kBackwardCapcity, kForwardCapacity)),
       deferred_(false),
       defer_allowed_(true),
       completed_(false),
       range_requested_(false),
       partial_response_(false),
+      bridge_factory_(bridge_factory),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       start_callback_(NULL),
+      bridge_(NULL),
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
-      last_offset_(0),
-      keep_test_loader_(false) {
+      last_offset_(0) {
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {
-  if (!completed_ && url_loader_.get())
-    url_loader_->cancel();
 }
 
 void BufferedResourceLoader::Start(net::CompletionCallback* start_callback,
-                                   NetworkEventCallback* event_callback,
-                                   WebFrame* frame) {
+                                   NetworkEventCallback* event_callback) {
   // Make sure we have not started.
+  DCHECK(!bridge_.get());
   DCHECK(!start_callback_.get());
   DCHECK(!event_callback_.get());
   DCHECK(start_callback);
   DCHECK(event_callback);
-  CHECK(frame);
 
   start_callback_.reset(start_callback);
   event_callback_.reset(event_callback);
 
   if (first_byte_position_ != kPositionNotSpecified) {
     range_requested_ = true;
     // TODO(hclam): server may not support range request so |offset_| may not
     // equal to |first_byte_position_|.
     offset_ = first_byte_position_;
   }
 
+  // Creates the bridge on render thread since we can only access
+  // ResourceDispatcher on this thread.
+  bridge_.reset(
+      bridge_factory_->CreateBridge(
+          url_,
+          net::LOAD_NORMAL,
+          first_byte_position_,
+          last_byte_position_));
+
   // Increment the reference count right before we start the request. This
   // reference will be release when this request has ended.
   AddRef();
 
-  // Prepare the request.
-  WebURLRequest request(url_);
-  request.setHTTPHeaderField(WebString::fromUTF8("Range"),
-                             WebString::fromUTF8(GenerateHeaders(
-                                                 first_byte_position_,
-                                                 last_byte_position_)));
-  frame->setReferrerForRequest(request, WebKit::WebURL());
-  // TODO(annacc): we should be using createAssociatedURLLoader() instead?
-  frame->dispatchWillSendRequest(request);
-
-  // This flag is for unittests as we don't want to reset |url_loader|
-  if (!keep_test_loader_)
-    url_loader_.reset(WebKit::webKitClient()->createURLLoader());
-
-  // Start the resource loading.
-  url_loader_->loadAsynchronously(request, this);
+  // And start the resource loading.
+  bridge_->Start(this);
 }
 
 void BufferedResourceLoader::Stop() {
   // Reset callbacks.
   start_callback_.reset();
   event_callback_.reset();
   read_callback_.reset();
 
   // Use the internal buffer to signal that we have been stopped.
   // TODO(hclam): Not so pretty to do this.
   if (!buffer_.get())
     return;
 
   // Destroy internal buffer.
   buffer_.reset();
 
-  if (url_loader_.get()) {
+  if (bridge_.get()) {
+    // Cancel the request. This method call will cancel the request
+    // asynchronously. We may still get data or messages until we receive
+    // a response completed message.
     if (deferred_)
-      url_loader_->setDefersLoading(false);
+      bridge_->SetDefersLoading(false);
     deferred_ = false;
-
-    if (!completed_) {
-      url_loader_->cancel();
-      completed_ = true;
-    }
+    bridge_->Cancel();
   }
 }
 
 void BufferedResourceLoader::Read(int64 position,
                                   int read_size,
                                   uint8* buffer,
                                   net::CompletionCallback* read_callback) {
   DCHECK(!read_callback_.get());
   DCHECK(buffer_.get());
   DCHECK(read_callback);
@@ skipping 50 matching lines @@
   if (buffer_.get())
     return offset_ + static_cast<int>(buffer_->forward_bytes()) - 1;
   return kPositionNotSpecified;
 }
 
 void BufferedResourceLoader::SetAllowDefer(bool is_allowed) {
   defer_allowed_ = is_allowed;
   DisableDeferIfNeeded();
 }
 
-void BufferedResourceLoader::SetURLLoaderForTest(WebURLLoader* mock_loader) {
-  url_loader_.reset(mock_loader);
-  keep_test_loader_ = true;
-}
+/////////////////////////////////////////////////////////////////////////////
+// BufferedResourceLoader,
+//     webkit_glue::ResourceLoaderBridge::Peer implementations
+bool BufferedResourceLoader::OnReceivedRedirect(
+    const GURL& new_url,
+    const webkit_glue::ResourceResponseInfo& info,
+    bool* has_new_first_party_for_cookies,
+    GURL* new_first_party_for_cookies) {
+  DCHECK(bridge_.get());
 
-/////////////////////////////////////////////////////////////////////////////
-// BufferedResourceLoader, WebKit::WebURLLoaderClient implementations.
-void BufferedResourceLoader::willSendRequest(
-    WebURLLoader* loader,
-    WebURLRequest& newRequest,
-    const WebURLResponse& redirectResponse) {
+  // Save the new URL.
+  url_ = new_url;
+  // TODO(wtc): should we return a new first party for cookies URL?
+  *has_new_first_party_for_cookies = false;
 
   // The load may have been stopped and |start_callback| is destroyed.
   // In this case we shouldn't do anything.
-  if (!start_callback_.get()) {
-    // Set the url in the request to an invalid value (empty url).
-    newRequest.setURL(WebKit::WebURL());
-    return;
-  }
+  if (!start_callback_.get())
+    return true;
 
-  if (!IsProtocolSupportedForMedia(newRequest.url())) {
-    // Set the url in the request to an invalid value (empty url).
-    newRequest.setURL(WebKit::WebURL());
+  if (!IsProtocolSupportedForMedia(new_url)) {
     DoneStart(net::ERR_ADDRESS_INVALID);
     Stop();
-    return;
+    return false;
   }
-
-  url_ = newRequest.url();
+  return true;
 }
 
-void BufferedResourceLoader::didSendData(
-    WebURLLoader* loader,
-    unsigned long long bytes_sent,
-    unsigned long long total_bytes_to_be_sent) {
-  NOTIMPLEMENTED();
-}
-
-void BufferedResourceLoader::didReceiveResponse(
-    WebURLLoader* loader,
-    const WebURLResponse& response) {
+void BufferedResourceLoader::OnReceivedResponse(
+    const webkit_glue::ResourceResponseInfo& info,
+    bool content_filtered) {
+  DCHECK(bridge_.get());
 
   // The loader may have been stopped and |start_callback| is destroyed.
   // In this case we shouldn't do anything.
   if (!start_callback_.get())
     return;
 
   // 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 (IsHttpProtocol(url_)) {
     int error = net::OK;
+    if (!info.headers) {
+      // We expect to receive headers because this is a HTTP or HTTPS protocol,
+      // if not report failure.
+      error = net::ERR_INVALID_RESPONSE;
+    } else {
+      if (info.headers->response_code() == kHttpPartialContent)
+        partial_response_ = true;
 
-    if (response.httpStatusCode() == kHttpPartialContent)
-      partial_response_ = true;
-
-    if (range_requested_ && partial_response_) {
-      // If we have verified the partial response and it is correct, we will
-      // return net::OK.
-      if (!VerifyPartialResponse(response))
-        error = net::ERR_INVALID_RESPONSE;
-    } else if (response.httpStatusCode() != kHttpOK) {
-      // We didn't request a range but server didn't reply with "200 OK".
-      error = net::ERR_FAILED;
+      if (range_requested_ && partial_response_) {
+        // If we have verified the partial response and it is correct, we will
+        // return net::OK.
+        if (!VerifyPartialResponse(info))
+          error = net::ERR_INVALID_RESPONSE;
+      } else if (info.headers->response_code() != kHttpOK) {
+        // We didn't request a range but server didn't reply with "200 OK".
+        error = net::ERR_FAILED;
+      }
     }
 
     if (error != net::OK) {
       DoneStart(error);
       Stop();
       return;
     }
   } else {
     // For any protocol other than HTTP and HTTPS, assume range request is
     // always fulfilled.
     partial_response_ = range_requested_;
   }
 
-  // Expected content length can be -1, in that case |content_length_| is
+  // |info.content_length| can be -1, in that case |content_length_| is
   // not specified and this is a streaming response.
-  content_length_ = response.expectedContentLength();
+  content_length_ = info.content_length;
 
   // If we have not requested a range, then the size of the instance is equal
   // to the content length.
   if (!partial_response_)
     instance_size_ = content_length_;
 
   // Calls with a successful response.
   DoneStart(net::OK);
 }
 
-void BufferedResourceLoader::didReceiveData(
-    WebURLLoader* loader,
-    const char* data,
-    int data_length) {
-  DCHECK(!completed_);
-  DCHECK_GT(data_length, 0);
+void BufferedResourceLoader::OnReceivedData(const char* data, int len) {
+  DCHECK(bridge_.get());
 
   // If this loader has been stopped, |buffer_| would be destroyed.
   // In this case we shouldn't do anything.
   if (!buffer_.get())
     return;
 
   // Writes more data to |buffer_|.
-  buffer_->Append(reinterpret_cast<const uint8*>(data), data_length);
+  buffer_->Append(reinterpret_cast<const uint8*>(data), len);
 
   // If there is an active read request, try to fulfill the request.
   if (HasPendingRead() && CanFulfillRead()) {
     ReadInternal();
   } else if (!defer_allowed_) {
     // If we're not allowed to defer, slide the buffer window forward instead
     // of deferring.
     if (buffer_->forward_bytes() > buffer_->forward_capacity()) {
       size_t excess = buffer_->forward_bytes() - buffer_->forward_capacity();
       bool success = buffer_->Seek(excess);
       DCHECK(success);
       offset_ += first_offset_ + excess;
     }
   }
 
   // At last see if the buffer is full and we need to defer the downloading.
   EnableDeferIfNeeded();
 
   // Notify that we have received some data.
   NotifyNetworkEvent();
 }
 
-void BufferedResourceLoader::didDownloadData(
-    WebKit::WebURLLoader* loader,
-    int dataLength) {
-  NOTIMPLEMENTED();
-}
+void BufferedResourceLoader::OnCompletedRequest(
+    const URLRequestStatus& status,
+    const std::string& security_info,
+    const base::Time& completion_time) {
+  DCHECK(bridge_.get());
 
-void BufferedResourceLoader::didReceiveCachedMetadata(
-    WebURLLoader* loader,
-    const char* data,
-    int data_length) {
-  NOTIMPLEMENTED();
-}
-
-void BufferedResourceLoader::didFinishLoading(
-    WebURLLoader* loader,
-    double finishTime) {
-  DCHECK(!completed_);
+  // Saves the information that the request has completed.
   completed_ = true;
 
   // If there is a start callback, calls it.
   if (start_callback_.get()) {
-    DoneStart(net::OK);
+    DoneStart(status.os_error());
   }
 
   // If there is a pending read but the request has ended, returns with what
   // we have.
   if (HasPendingRead()) {
     // Make sure we have a valid buffer before we satisfy a read request.
     DCHECK(buffer_.get());
 
-    // Try to fulfill with what is in the buffer.
-    if (CanFulfillRead())
-      ReadInternal();
-    else
-      DoneRead(net::ERR_CACHE_MISS);
+    if (status.is_success()) {
+      // Try to fulfill with what is in the buffer.
+      if (CanFulfillRead())
+        ReadInternal();
+      else
+        DoneRead(net::ERR_CACHE_MISS);
+    } else {
+      // If the request has failed, then fail the read.
+      DoneRead(net::ERR_FAILED);
+    }
   }
 
   // There must not be any outstanding read request.
   DCHECK(!HasPendingRead());
 
   // Notify that network response is completed.
   NotifyNetworkEvent();
 
-  url_loader_.reset();
-  Release();
-}
-
-void BufferedResourceLoader::didFail(
-    WebURLLoader* loader,
-    const WebURLError& error) {
-  DCHECK(!completed_);
-  completed_ = true;
-
-  // If there is a start callback, calls it.
-  if (start_callback_.get()) {
-    DoneStart(error.reason);
-  }
-
-  // If there is a pending read but the request failed, return with the
-  // reason for the error.
-  if (HasPendingRead()) {
-    DoneRead(error.reason);
-  }
-
-  // Notify that network response is completed.
-  NotifyNetworkEvent();
-
-  url_loader_.reset();
+  // We incremented the reference count when the loader was started. We balance
+  // that reference here so that we get destroyed. This is also the only safe
+  // place to destroy the ResourceLoaderBridge.
+  bridge_.reset();
   Release();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader, private
 void BufferedResourceLoader::EnableDeferIfNeeded() {
   if (!defer_allowed_)
     return;
 
   if (!deferred_ &&
       buffer_->forward_bytes() >= buffer_->forward_capacity()) {
     deferred_ = true;
 
-  if (url_loader_.get())
-    url_loader_->setDefersLoading(true);
+    if (bridge_.get())
+      bridge_->SetDefersLoading(true);
 
     NotifyNetworkEvent();
   }
 }
 
 void BufferedResourceLoader::DisableDeferIfNeeded() {
   if (deferred_ &&
       (!defer_allowed_ ||
        buffer_->forward_bytes() < buffer_->forward_capacity() / 2)) {
     deferred_ = false;
 
-    if (url_loader_.get())
-      url_loader_->setDefersLoading(false);
+    if (bridge_.get())
+      bridge_->SetDefersLoading(false);
 
     NotifyNetworkEvent();
   }
 }
 
 bool BufferedResourceLoader::CanFulfillRead() {
   // If we are reading too far in the backward direction.
   if (first_offset_ < 0 &&
       first_offset_ + static_cast<int>(buffer_->backward_bytes()) < 0)
     return false;
@@ skipping 40 matching lines @@
 
   // Then do the read.
   int read = static_cast<int>(buffer_->Read(read_buffer_, read_size_));
   offset_ += first_offset_ + read;
 
   // And report with what we have read.
   DoneRead(read);
 }
 
 bool BufferedResourceLoader::VerifyPartialResponse(
-    const WebURLResponse& response) {
-  int first_byte_position, last_byte_position, instance_size;
-
-  if (!MultipartResponseDelegate::ReadContentRanges(response,
-                         &first_byte_position,
-                         &last_byte_position,
-                         &instance_size)) {
+    const ResourceResponseInfo& info) {
+  int64 first_byte_position, last_byte_position, instance_size;
+  if (!info.headers->GetContentRange(&first_byte_position,
+                                     &last_byte_position,
+                                     &instance_size)) {
     return false;
   }
 
-  if (instance_size != kPositionNotSpecified) {
+  if (instance_size != kPositionNotSpecified)
     instance_size_ = instance_size;
-  }
 
-  if (first_byte_position_ != kPositionNotSpecified &&
+  if (first_byte_position_ != -1 &&
       first_byte_position_ != first_byte_position) {
     return false;
   }
 
   // TODO(hclam): I should also check |last_byte_position|, but since
   // we will never make such a request that it is ok to leave it unimplemented.
   return true;
 }
 
-std::string BufferedResourceLoader::GenerateHeaders(
-    int64 first_byte_position,
-    int64 last_byte_position) {
-  // Construct the value for the range header.
-  std::string header;
-  if (first_byte_position > kPositionNotSpecified &&
-      last_byte_position > kPositionNotSpecified) {
-    if (first_byte_position <= last_byte_position) {
-      header = base::StringPrintf("bytes=%" PRId64 "-%" PRId64,
-                                  first_byte_position,
-                                  last_byte_position);
-    }
-  } else if (first_byte_position > kPositionNotSpecified) {
-    header = base::StringPrintf("bytes=%" PRId64 "-",
-                                first_byte_position);
-  } else if (last_byte_position > kPositionNotSpecified) {
-    NOTIMPLEMENTED() << "Suffix range not implemented";
-  }
-  return header;
-}
-
 void BufferedResourceLoader::DoneRead(int error) {
   read_callback_->RunWithParams(Tuple1<int>(error));
   read_callback_.reset();
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = NULL;
   first_offset_ = 0;
   last_offset_ = 0;
 }
 
 void BufferedResourceLoader::DoneStart(int error) {
   start_callback_->RunWithParams(Tuple1<int>(error));
   start_callback_.reset();
 }
 
 void BufferedResourceLoader::NotifyNetworkEvent() {
   if (event_callback_.get())
     event_callback_->Run();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
-    WebFrame* frame)
+    webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory)
     : total_bytes_(kPositionNotSpecified),
       loaded_(false),
       streaming_(false),
-      frame_(frame),
       single_origin_(true),
+      bridge_factory_(bridge_factory),
       loader_(NULL),
       network_activity_(false),
       initialize_callback_(NULL),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       read_attempts_(0),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       stopped_on_render_loop_(false),
       media_is_paused_(true),
       using_range_request_(true) {
 }
 
 BufferedDataSource::~BufferedDataSource() {
 }
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overrided to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(MessageLoop::current() == render_loop_);
 
-  return new BufferedResourceLoader(url_,
+  return new BufferedResourceLoader(bridge_factory_.get(), url_,
                                     first_byte_position,
                                     last_byte_position);
 }
 
 // This method simply returns kTimeoutMilliseconds. The purpose of this
 // method is to be overidded so as to provide a different timeout value
 // for testing purpose.
 base::TimeDelta BufferedDataSource::GetTimeoutMilliseconds() {
   return base::TimeDelta::FromMilliseconds(kTimeoutMilliseconds);
 }
@@ skipping 79 matching lines @@
   DCHECK(MessageLoop::current() == render_loop_);
   return single_origin_;
 }
 
 void BufferedDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // If we are told to abort, immediately return from any pending read
   // with an error.
   if (read_callback_.get()) {
+    {
       AutoLock auto_lock(lock_);
       DoneRead_Locked(net::ERR_FAILED);
+    }
+    CleanupTask();
   }
-
-  CleanupTask();
-  frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, render thread tasks
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
   DCHECK(!stopped_on_render_loop_);
 
   // Kick starts the watch dog task that will handle connection timeout.
   // We run the watch dog 2 times faster the actual timeout so as to catch
   // the timeout more accurately.
   watch_dog_timer_.Start(
       GetTimeoutMilliseconds() / 2,
       this,
       &BufferedDataSource::WatchDogTask);
 
   if (IsHttpProtocol(url_)) {
     // Fetch only first 1024 bytes as this usually covers the header portion
     // of a media file that gives enough information about the codecs, etc.
     // This also serve as a probe to determine server capability to serve
     // range request.
     // TODO(hclam): Do some experiments for the best approach.
     loader_ = CreateResourceLoader(0, 1024);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
-        NewCallback(this, &BufferedDataSource::NetworkEventCallback),
-        frame_);
+        NewCallback(this, &BufferedDataSource::NetworkEventCallback));
   } else {
     // For all other protocols, assume they support range request. We fetch
     // the full range of the resource to obtain the instance size because
     // we won't be served HTTP headers.
     loader_ = CreateResourceLoader(-1, -1);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::NonHttpInitialStartCallback),
-        NewCallback(this, &BufferedDataSource::NetworkEventCallback),
-        frame_);
+        NewCallback(this, &BufferedDataSource::NetworkEventCallback));
   }
 }
 
 void BufferedDataSource::ReadTask(
      int64 position, int read_size, uint8* buffer,
      media::DataSource::ReadCallback* read_callback) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // If CleanupTask() was executed we should return immediately. We check this
   // variable to prevent doing any actual work after clean up was done. We do
@@ skipping 56 matching lines @@
     return;
 
   // If there's no outstanding read then return early.
   if (!read_callback_.get())
     return;
 
   loader_ = CreateResourceLoader(read_position_, -1);
   loader_->SetAllowDefer(!media_is_paused_);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
-      NewCallback(this, &BufferedDataSource::NetworkEventCallback),
-      frame_);
+      NewCallback(this, &BufferedDataSource::NetworkEventCallback));
 }
 
 void BufferedDataSource::WatchDogTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!stopped_on_render_loop_);
 
   // We only care if there is an active read request.
   if (!read_callback_.get())
     return;
 
@@ skipping 10 matching lines @@
   ++read_attempts_;
   read_submitted_time_ = base::Time::Now();
 
   // Stops the current loader and creates a new resource loader and
   // retry the request.
   loader_->Stop();
   loader_ = CreateResourceLoader(read_position_, -1);
   loader_->SetAllowDefer(!media_is_paused_);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
-      NewCallback(this, &BufferedDataSource::NetworkEventCallback),
-      frame_);
+      NewCallback(this, &BufferedDataSource::NetworkEventCallback));
 }
 
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   bool previously_paused = media_is_paused_;
   media_is_paused_ = (playback_rate == 0.0);
 
   // Disallow deferring data when we are pausing, allow deferring data
   // when we resume playing.
   if (previously_paused && !media_is_paused_) {
     loader_->SetAllowDefer(true);
   } else if (!previously_paused && media_is_paused_) {
     loader_->SetAllowDefer(false);
   }
 }
 
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(loader_);
+  DCHECK(loader_.get());
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (read_size_ > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[read_size_]);
   }
 
   // Perform the actual read with BufferedResourceLoader.
   loader_->Read(read_position_, read_size_, intermediate_read_buffer_.get(),
                 NewCallback(this, &BufferedDataSource::ReadCallback));
@@ skipping 54 matching lines @@
     loader_->Stop();
   }
 
   if (error == net::ERR_INVALID_RESPONSE && using_range_request_) {
     // Assuming that the Range header was causing the problem. Retry without
     // the Range header.
     using_range_request_ = false;
     loader_ = CreateResourceLoader(-1, -1);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
-        NewCallback(this, &BufferedDataSource::NetworkEventCallback),
-        frame_);
+        NewCallback(this, &BufferedDataSource::NetworkEventCallback));
     return;
   }
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. The only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
@@ skipping 159 matching lines @@
     return;
 
   if (network_activity != network_activity_) {
     network_activity_ = network_activity;
     host()->SetNetworkActivity(network_activity);
   }
   host()->SetBufferedBytes(buffered_last_byte_position + 1);
 }
 
 }  // namespace webkit_glue