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

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::WebFrame* frame)
+    webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory)
     : render_loop_(render_loop),
-      frame_(frame),
+      bridge_factory_(bridge_factory),
       size_(-1),
       single_origin_(true),
-      state_(UNINITIALIZED),
-      keep_test_loader_(false) {
+      state_(UNINITIALIZED) {
   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;
 }
 
-void SimpleDataSource::SetURLLoaderForTest(WebKit::WebURLLoader* mock_loader) {
-  url_loader_.reset(mock_loader);
-  keep_test_loader_ = true;
+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::willSendRequest(
-    WebKit::WebURLLoader* loader,
-    WebKit::WebURLRequest& newRequest,
-    const WebKit::WebURLResponse& redirectResponse) {
+void SimpleDataSource::OnReceivedResponse(
+    const webkit_glue::ResourceResponseInfo& info,
+    bool content_filtered) {
   DCHECK(MessageLoop::current() == render_loop_);
-  single_origin_ = url_.GetOrigin() == GURL(newRequest.url()).GetOrigin();
-
-  url_ = newRequest.url();
+  size_ = info.content_length;
 }
 
-void SimpleDataSource::didSendData(
-    WebKit::WebURLLoader* loader,
-    unsigned long long bytesSent,
-    unsigned long long totalBytesToBeSent) {
-  NOTIMPLEMENTED();
+void SimpleDataSource::OnReceivedData(const char* data, int len) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  data_.append(data, len);
 }
 
-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) {
+void SimpleDataSource::OnCompletedRequest(const URLRequestStatus& status,
+                                          const std::string& security_info,
+                                          const base::Time& completion_time) {
   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.
+  // Otherwise we should be initializing and have created a bridge.
   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(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 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(false);
+  DoneInitialization_Locked(status.is_success());
 }
 
 bool SimpleDataSource::HasSingleOrigin() {
   DCHECK(MessageLoop::current() == render_loop_);
   return single_origin_;
 }
 
 void SimpleDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
-  frame_ = NULL;
+  NOTIMPLEMENTED();
 }
 
 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 {
-    // 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);
+    // Create our bridge and start loading the resource.
+    bridge_.reset(bridge_factory_->CreateBridge(
+        url_, net::LOAD_BYPASS_CACHE, -1, -1));
+    bridge_->Start(this);
   }
 }
 
 void SimpleDataSource::CancelTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, STOPPED);
 
   // Cancel any pending requests.
-  if (url_loader_.get()) {
-    url_loader_->cancel();
-    url_loader_.reset();
+  if (bridge_.get()) {
+    bridge_->Cancel();
+    bridge_.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