Refactoring BufferedDataSource to work with WebURLLoader instead of a MediaResourceLoaderBridge.

webkit/glue/media/simple_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/message_loop.h"
 #include "base/process_util.h"
 #include "media/base/filter_host.h"
 #include "net/base/load_flags.h"
 #include "net/base/data_url.h"
-#include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_status.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebKit.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebKitClient.h"
 #include "webkit/glue/media/simple_data_source.h"
-#include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/glue/webkit_glue.h"
 
 namespace {
 
 const char kHttpScheme[] = "http";
 const char kHttpsScheme[] = "https";
 const char kDataScheme[] = "data";
 
 // A helper method that accepts only HTTP, HTTPS and FILE protocol.
 bool IsDataProtocol(const GURL& url) {
   return url.SchemeIs(kDataScheme);
 }
 
 }  // namespace
 
 namespace webkit_glue {
 
 SimpleDataSource::SimpleDataSource(
     MessageLoop* render_loop,
-    webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory)
+    WebKit::WebFrame* frame)
     : render_loop_(render_loop),
-      bridge_factory_(bridge_factory),
+      frame_(frame),
       size_(-1),
       single_origin_(true),
-      state_(UNINITIALIZED) {
+      state_(UNINITIALIZED),
+      keep_test_loader_(false) {
   DCHECK(render_loop);
 }
 
 SimpleDataSource::~SimpleDataSource() {
   AutoLock auto_lock(lock_);
   DCHECK(state_ == UNINITIALIZED || state_ == STOPPED);
 }
 
 void SimpleDataSource::Stop(media::FilterCallback* callback) {
   AutoLock auto_lock(lock_);
@@ skipping 52 matching lines @@
 
 bool SimpleDataSource::GetSize(int64* size_out) {
   *size_out = size_;
   return true;
 }
 
 bool SimpleDataSource::IsStreaming() {
   return false;
 }
 
-bool SimpleDataSource::OnReceivedRedirect(
-    const GURL& new_url,
-    const webkit_glue::ResourceResponseInfo& info,
-    bool* has_new_first_party_for_cookies,
-    GURL* new_first_party_for_cookies) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  single_origin_ = url_.GetOrigin() == new_url.GetOrigin();
-
-  // TODO(wtc): should we return a new first party for cookies URL?
-  *has_new_first_party_for_cookies = false;
-  return true;
+void SimpleDataSource::SetURLLoaderForTest(WebKit::WebURLLoader* mock_loader) {
+  url_loader_.reset(mock_loader);
+  keep_test_loader_ = true;
 }
 
-void SimpleDataSource::OnReceivedResponse(
-    const webkit_glue::ResourceResponseInfo& info,
-    bool content_filtered) {
+void SimpleDataSource::willSendRequest(
+    WebKit::WebURLLoader* loader,
+    WebKit::WebURLRequest& newRequest,
+    const WebKit::WebURLResponse& redirectResponse) {
   DCHECK(MessageLoop::current() == render_loop_);
-  size_ = info.content_length;
+  single_origin_ = url_.GetOrigin() == GURL(newRequest.url()).GetOrigin();
+
+  url_ = newRequest.url();
 }
 
-void SimpleDataSource::OnReceivedData(const char* data, int len) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  data_.append(data, len);
+void SimpleDataSource::didSendData(
+    WebKit::WebURLLoader* loader,
+    unsigned long long bytesSent,
+    unsigned long long totalBytesToBeSent) {
+  NOTIMPLEMENTED();
 }
 
-void SimpleDataSource::OnCompletedRequest(const URLRequestStatus& status,
-                                          const std::string& security_info,
-                                          const base::Time& completion_time) {
+void SimpleDataSource::didReceiveResponse(
+    WebKit::WebURLLoader* loader,
+    const WebKit::WebURLResponse& response) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  size_ = response.expectedContentLength();
+}
+
+void SimpleDataSource::didDownloadData(
+    WebKit::WebURLLoader* loader,
+    int dataLength) {
+  NOTIMPLEMENTED();
+}
+
+void SimpleDataSource::didReceiveData(
+    WebKit::WebURLLoader* loader,
+    const char* data,
+    int data_length) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  data_.append(data, data_length);
+}
+
+void SimpleDataSource::didReceiveCachedMetadata(
+    WebKit::WebURLLoader* loader,
+    const char* data,
+    int dataLength) {
+  NOTIMPLEMENTED();
+}
+
+void SimpleDataSource::didFinishLoading(
+    WebKit::WebURLLoader* loader,
+    double finishTime) {
   DCHECK(MessageLoop::current() == render_loop_);
   AutoLock auto_lock(lock_);
   // It's possible this gets called after Stop(), in which case |host_| is no
+  // longer valid.
+  if (state_ == STOPPED)
+    return;
+
+  // Otherwise we should be initializing and have created a WebURLLoader.
+  DCHECK_EQ(state_, INITIALIZING);
+
+  // If we don't get a content length or the request has failed, report it
+  // as a network error.
+  if (size_ == -1)
+    size_ = data_.length();
+  DCHECK(static_cast<size_t>(size_) == data_.length());
+
+  DoneInitialization_Locked(true);
+}
+
+void SimpleDataSource::didFail(
+    WebKit::WebURLLoader* loader,
+    const WebKit::WebURLError& error) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  AutoLock auto_lock(lock_);
+  // It's possible this gets called after Stop(), in which case |host_| is no
   // longer valid.
   if (state_ == STOPPED)
     return;
 
-  // Otherwise we should be initializing and have created a bridge.
+  // Otherwise we should be initializing and have created a WebURLLoader.
   DCHECK_EQ(state_, INITIALIZING);
-  DCHECK(bridge_.get());
-  bridge_.reset();
 
   // If we don't get a content length or the request has failed, report it
   // as a network error.
   if (size_ == -1)
     size_ = data_.length();
   DCHECK(static_cast<size_t>(size_) == data_.length());
 
-  DoneInitialization_Locked(status.is_success());
+  DoneInitialization_Locked(false);
 }
 
 bool SimpleDataSource::HasSingleOrigin() {
   DCHECK(MessageLoop::current() == render_loop_);
   return single_origin_;
 }
 
 void SimpleDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
-  NOTIMPLEMENTED();
+  frame_ = NULL;
 }
 
 void SimpleDataSource::SetURL(const GURL& url) {
   url_ = url;
   media_format_.Clear();
   media_format_.SetAsString(media::MediaFormat::kMimeType,
                             media::mime_type::kApplicationOctetStream);
   media_format_.SetAsString(media::MediaFormat::kURL, url.spec());
 }
 
 void SimpleDataSource::StartTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   AutoLock auto_lock(lock_);
 
   // We may have stopped.
   if (state_ == STOPPED)
     return;
 
+  CHECK(frame_);
+
   DCHECK_EQ(state_, INITIALIZING);
 
   if (IsDataProtocol(url_)) {
     // If this using data protocol, we just need to decode it.
     std::string mime_type, charset;
     bool success = net::DataURL::Parse(url_, &mime_type, &charset, &data_);
 
     // Don't care about the mime-type just proceed if decoding was successful.
     size_ = data_.length();
     DoneInitialization_Locked(success);
   } else {
-    // Create our bridge and start loading the resource.
-    bridge_.reset(bridge_factory_->CreateBridge(
-        url_, net::LOAD_BYPASS_CACHE, -1, -1));
-    bridge_->Start(this);
+    // Prepare the request.
+    WebKit::WebURLRequest request(url_);
+
+    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);
   }
 }
 
 void SimpleDataSource::CancelTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, STOPPED);
 
   // Cancel any pending requests.
-  if (bridge_.get()) {
-    bridge_->Cancel();
-    bridge_.reset();
+  if (url_loader_.get()) {
+    url_loader_->cancel();
+    url_loader_.reset();
   }
 }
 
 void SimpleDataSource::DoneInitialization_Locked(bool success) {
   lock_.AssertAcquired();
   if (success) {
     state_ = INITIALIZED;
     host()->SetTotalBytes(size_);
     host()->SetBufferedBytes(size_);
     // If scheme is file or data, say we are loaded.
     host()->SetLoaded(url_.SchemeIsFile() || IsDataProtocol(url_));
   } else {
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
   }
   initialize_callback_->Run();
   initialize_callback_.reset();
 }
 
 }  // namespace webkit_glue