AssociatedURLLoader shouldn't derive from WebURLLoader

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"
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/blink/active_loader.h"
 #include "media/blink/cache_util.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/url_index.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/web/WebAssociatedURLLoader.h"
 
+using blink::WebAssociatedURLLoader;
+using blink::WebAssociatedURLLoaderOptions;
 using blink::WebFrame;
 using blink::WebString;
 using blink::WebURLError;
-using blink::WebURLLoader;
-using blink::WebURLLoaderOptions;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 namespace media {
 
 // The number of milliseconds to wait before retrying a failed load.
 const int kLoaderFailedRetryDelayMs = 250;
 
 // Each retry, add this many MS to the delay.
 // total delay is:
@@ skipping 46 matching lines @@
                                WebString::fromUTF8(url_data_->etag()));
   }
 
   url_data_->frame()->setReferrerForRequest(request, blink::WebURL());
 
   // Disable compression, compression for audio/video doesn't make sense...
   request.setHTTPHeaderField(
       WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding),
       WebString::fromUTF8("identity;q=1, *;q=0"));
 
-  // Check for our test WebURLLoader.
-  std::unique_ptr<WebURLLoader> loader;
+  // Check for our test WebAssociatedURLLoader.
+  std::unique_ptr<WebAssociatedURLLoader> loader;
   if (test_loader_) {
     loader = std::move(test_loader_);
   } else {
-    WebURLLoaderOptions options;
+    WebAssociatedURLLoaderOptions options;
     if (url_data_->cors_mode() == UrlData::CORS_UNSPECIFIED) {
       options.allowCredentials = true;
       options.crossOriginRequestPolicy =
-          WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
+          WebAssociatedURLLoaderOptions::CrossOriginRequestPolicyAllow;
     } else {
       options.exposeAllResponseHeaders = true;
       // The author header set is empty, no preflight should go ahead.
-      options.preflightPolicy = WebURLLoaderOptions::PreventPreflight;
-      options.crossOriginRequestPolicy =
-          WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
+      options.preflightPolicy = WebAssociatedURLLoaderOptions::PreventPreflight;
+      options.crossOriginRequestPolicy = WebAssociatedURLLoaderOptions::
+          CrossOriginRequestPolicyUseAccessControl;
       if (url_data_->cors_mode() == UrlData::CORS_USE_CREDENTIALS)
         options.allowCredentials = true;
     }
     loader.reset(url_data_->frame()->createAssociatedURLLoader(options));
   }
 
   // Start the resource loading.
   loader->loadAsynchronously(request, this);
   active_loader_.reset(new ActiveLoader(std::move(loader)));
 }
@@ skipping 34 matching lines @@
   return ret;
 }
 
 void ResourceMultiBufferDataProvider::SetDeferred(bool deferred) {
   if (!active_loader_ || active_loader_->deferred() == deferred)
     return;
   active_loader_->SetDeferred(deferred);
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// WebURLLoaderClient implementation.
+// WebAssociatedURLLoaderClient implementation.
 
 bool ResourceMultiBufferDataProvider::willFollowRedirect(
-    WebURLLoader* loader,
-    WebURLRequest& newRequest,
+    const WebURLRequest& newRequest,
     const WebURLResponse& redirectResponse) {
   redirects_to_ = newRequest.url();
   url_data_->set_valid_until(base::Time::Now() +
                              GetCacheValidUntil(redirectResponse));
 
   // This test is vital for security!
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED) {
     // We allow the redirect if the origin is the same.
     if (origin_ != redirects_to_.GetOrigin()) {
       // We also allow the redirect if we don't have any data in the
       // cache, as that means that no dangerous data mixing can occur.
       if (url_data_->multibuffer()->map().empty() && fifo_.empty())
         return true;
 
       active_loader_ = nullptr;
       url_data_->Fail();
       return false;  // "this" may be deleted now.
     }
   }
   return true;
 }
 
 void ResourceMultiBufferDataProvider::didSendData(
-    WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   NOTIMPLEMENTED();
 }
 
 void ResourceMultiBufferDataProvider::didReceiveResponse(
-    WebURLLoader* loader,
     const WebURLResponse& response) {
 #if ENABLE_DLOG
   string version;
   switch (response.httpVersion()) {
     case WebURLResponse::HTTPVersion_0_9:
       version = "0.9";
       break;
     case WebURLResponse::HTTPVersion_1_0:
       version = "1.0";
       break;
@@ skipping 136 matching lines @@
     url_data_->Fail();
     return;  // "this" may be deleted now.
   }
 
   if (end_of_file) {
     fifo_.push_back(DataBuffer::CreateEOSBuffer());
     url_data_->multibuffer()->OnDataProviderEvent(this);
   }
 }
 
-void ResourceMultiBufferDataProvider::didReceiveData(WebURLLoader* loader,
-                                                     const char* data,
-                                                     int data_length,
-                                                     int encoded_data_length,
-                                                     int encoded_body_length) {
+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);
 
   // 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);
     DCHECK_GT(to_append, 0);
     memcpy(fifo_.back()->writable_data() + last_block_size, data, to_append);
     data += to_append;
     fifo_.back()->set_data_size(last_block_size + to_append);
     data_length -= to_append;
   }
 
   url_data_->multibuffer()->OnDataProviderEvent(this);
 
   // Beware, this object might be deleted here.
 }
 
-void ResourceMultiBufferDataProvider::didDownloadData(WebURLLoader* loader,
-                                                      int dataLength,
-                                                      int encoded_data_length) {
+void ResourceMultiBufferDataProvider::didDownloadData(int dataLength) {
   NOTIMPLEMENTED();
 }
 
 void ResourceMultiBufferDataProvider::didReceiveCachedMetadata(
-    WebURLLoader* loader,
     const char* data,
     int data_length) {
   NOTIMPLEMENTED();
 }
 
-void ResourceMultiBufferDataProvider::didFinishLoading(
-    WebURLLoader* loader,
-    double finishTime,
-    int64_t total_encoded_data_length) {
+void ResourceMultiBufferDataProvider::didFinishLoading(double finishTime) {
   DVLOG(1) << "didFinishLoading";
   DCHECK(active_loader_.get());
   DCHECK(!Available());
 
   // We're done with the loader.
   active_loader_.reset();
 
   // If we didn't know the |instance_size_| we do now.
   int64_t size = byte_pos();
 
@@ skipping 18 matching lines @@
 
   url_data_->set_length(size);
   fifo_.push_back(DataBuffer::CreateEOSBuffer());
 
   DCHECK(Available());
   url_data_->multibuffer()->OnDataProviderEvent(this);
 
   // Beware, this object might be deleted here.
 }
 
-void ResourceMultiBufferDataProvider::didFail(WebURLLoader* loader,
-                                              const WebURLError& error) {
+void ResourceMultiBufferDataProvider::didFail(const WebURLError& error) {
   DVLOG(1) << "didFail: reason=" << error.reason
            << ", isCancellation=" << error.isCancellation
            << ", domain=" << error.domain.utf8().data()
            << ", localizedDescription="
            << error.localizedDescription.utf8().data();
   DCHECK(active_loader_.get());
 
   if (retries_ < kMaxRetries && pos_ != 0) {
     retries_++;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 87 matching lines @@
   }
 
   if (byte_pos() != first_byte_position) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace media