AssociatedURLLoader shouldn't derive from WebURLLoader

components/nacl/renderer/ppb_nacl_private_impl.cc

 // Copyright 2013 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 "components/nacl/renderer/ppb_nacl_private.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 45 matching lines @@
 #include "net/http/http_util.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/private/pp_file_handle.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
-#include "third_party/WebKit/public/platform/WebURLLoader.h"
+#include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/web/WebAssociatedURLLoader.h"
+#include "third_party/WebKit/public/web/WebAssociatedURLLoaderClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
-#include "third_party/WebKit/public/web/WebURLLoaderOptions.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 namespace nacl {
 namespace {
 
 // The pseudo-architecture used to indicate portable native client.
 const char* const kPortableArch = "portable";
@@ skipping 239 matching lines @@
     callback.Run(base::File(file_info.handle),
                  file_info.token_lo,
                  file_info.token_hi);
   }
 
   PP_Instance pp_instance_;
   NaClAppProcessType process_type_;
   DISALLOW_COPY_AND_ASSIGN(ManifestServiceProxy);
 };
 
-blink::WebURLLoader* CreateWebURLLoader(const blink::WebDocument& document,
-                                        const GURL& gurl) {
-  blink::WebURLLoaderOptions options;
+blink::WebAssociatedURLLoader* CreateAssociatedURLLoader(
+    const blink::WebDocument& document,
+    const GURL& gurl) {
+  blink::WebAssociatedURLLoaderOptions options;
   options.untrustedHTTP = true;
 
   // Options settings here follow the original behavior in the trusted
   // plugin and PepperURLLoaderHost.
   if (document.getSecurityOrigin().canRequest(gurl)) {
     options.allowCredentials = true;
   } else {
     // Allow CORS.
-    options.crossOriginRequestPolicy =
-        blink::WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
+    options.crossOriginRequestPolicy = blink::WebAssociatedURLLoaderOptions::
+        CrossOriginRequestPolicyUseAccessControl;
   }
   return document.frame()->createAssociatedURLLoader(options);
 }
 
 blink::WebURLRequest CreateWebURLRequest(const blink::WebDocument& document,
                                          const GURL& gurl) {
   blink::WebURLRequest request;
   request.setURL(gurl);
   request.setFirstPartyForCookies(document.firstPartyForCookies());
   return request;
@@ skipping 664 matching lines @@
   if (!load_manager || !plugin_instance) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->document();
 
   const GURL& gurl = load_manager->manifest_base_url();
-  std::unique_ptr<blink::WebURLLoader> url_loader(
-      CreateWebURLLoader(document, gurl));
+  std::unique_ptr<blink::WebAssociatedURLLoader> url_loader(
+      CreateAssociatedURLLoader(document, gurl));
   blink::WebURLRequest request = CreateWebURLRequest(document, gurl);
 
   // ManifestDownloader deletes itself after invoking the callback.
   ManifestDownloader* manifest_downloader = new ManifestDownloader(
       std::move(url_loader), load_manager->is_installed(),
       base::Bind(DownloadManifestToBufferCompletion, instance, callback,
                  base::Time::Now()));
   manifest_downloader->Load(request);
 }
 
@@ skipping 331 matching lines @@
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->document();
-  std::unique_ptr<blink::WebURLLoader> url_loader(
-      CreateWebURLLoader(document, gurl));
+  std::unique_ptr<blink::WebAssociatedURLLoader> url_loader(
+      CreateAssociatedURLLoader(document, gurl));
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
 
   ProgressEventRateLimiter* tracker = new ProgressEventRateLimiter(instance);
 
   // FileDownloader deletes itself after invoking DownloadNexeCompletion.
   FileDownloader* file_downloader = new FileDownloader(
       std::move(url_loader), std::move(target_file),
       base::Bind(&DownloadNexeCompletion, request, out_file_info),
       base::Bind(&ProgressEventRateLimiter::ReportProgress,
                  base::Owned(tracker), std::string(url)));
@@ skipping 130 matching lines @@
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED),
                               kInvalidNaClFileInfo));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->document();
-  std::unique_ptr<blink::WebURLLoader> url_loader(
-      CreateWebURLLoader(document, gurl));
+  std::unique_ptr<blink::WebAssociatedURLLoader> url_loader(
+      CreateAssociatedURLLoader(document, gurl));
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
 
   ProgressEventRateLimiter* tracker = new ProgressEventRateLimiter(instance);
 
   // FileDownloader deletes itself after invoking DownloadNexeCompletion.
   FileDownloader* file_downloader =
       new FileDownloader(std::move(url_loader), std::move(target_file),
                          base::Bind(&DownloadFileCompletion, callback),
                          base::Bind(&ProgressEventRateLimiter::ReportProgress,
                                     base::Owned(tracker), std::string(url)));
@@ skipping 30 matching lines @@
 void PPBNaClPrivate::SetPNaClStartTime(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->set_pnacl_start_time(base::Time::Now());
 }
 
 namespace {
 
 // PexeDownloader is responsible for deleting itself when the download
 // finishes.
-class PexeDownloader : public blink::WebURLLoaderClient {
+class PexeDownloader : public blink::WebAssociatedURLLoaderClient {
  public:
   PexeDownloader(PP_Instance instance,
-                 std::unique_ptr<blink::WebURLLoader> url_loader,
+                 std::unique_ptr<blink::WebAssociatedURLLoader> url_loader,
                  const std::string& pexe_url,
                  int32_t pexe_opt_level,
                  bool use_subzero,
                  const PPP_PexeStreamHandler* stream_handler,
                  void* stream_handler_user_data)
       : instance_(instance),
         url_loader_(std::move(url_loader)),
         pexe_url_(pexe_url),
         pexe_opt_level_(pexe_opt_level),
         use_subzero_(use_subzero),
         stream_handler_(stream_handler),
         stream_handler_user_data_(stream_handler_user_data),
         success_(false),
         expected_content_length_(-1),
         weak_factory_(this) {}
 
   void Load(const blink::WebURLRequest& request) {
     url_loader_->loadAsynchronously(request, this);
   }
 
  private:
-  void didReceiveResponse(blink::WebURLLoader* loader,
-                          const blink::WebURLResponse& response) override {
+  void didReceiveResponse(const blink::WebURLResponse& response) override {
     success_ = (response.httpStatusCode() == 200);
     if (!success_)
       return;
 
     expected_content_length_ = response.expectedContentLength();
 
     // Defer loading after receiving headers. This is because we may already
     // have a cached translated nexe, so check for that now.
     url_loader_->setDefersLoading(true);
 
@@ skipping 41 matching lines @@
     }
     stream_handler_->DidCacheMiss(stream_handler_user_data_,
                                   expected_content_length_,
                                   file_handle);
 
     // No translated nexe was found in the cache, so we should download the
     // file to start streaming it.
     url_loader_->setDefersLoading(false);
   }
 
-  void didReceiveData(blink::WebURLLoader* loader,
-                      const char* data,
-                      int data_length,
-                      int encoded_data_length,
-                      int encoded_body_length) override {
+  void didReceiveData(const char* data, int data_length) override {
     if (content::PepperPluginInstance::Get(instance_)) {
       // Stream the data we received to the stream callback.
       stream_handler_->DidStreamData(stream_handler_user_data_,
                                      data,
                                      data_length);
     }
   }
 
-  void didFinishLoading(blink::WebURLLoader* loader,
-                        double finish_time,
-                        int64_t total_encoded_data_length) override {
+  void didFinishLoading(double finish_time) override {
     int32_t result = success_ ? PP_OK : PP_ERROR_FAILED;
 
     if (content::PepperPluginInstance::Get(instance_))
       stream_handler_->DidFinishStream(stream_handler_user_data_, result);
     delete this;
   }
 
-  void didFail(blink::WebURLLoader* loader,
-               const blink::WebURLError& error) override {
+  void didFail(const blink::WebURLError& error) override {
     if (content::PepperPluginInstance::Get(instance_))
       stream_handler_->DidFinishStream(stream_handler_user_data_,
                                        PP_ERROR_FAILED);
     delete this;
   }
 
   PP_Instance instance_;
-  std::unique_ptr<blink::WebURLLoader> url_loader_;
+  std::unique_ptr<blink::WebAssociatedURLLoader> url_loader_;
   std::string pexe_url_;
   int32_t pexe_opt_level_;
   bool use_subzero_;
   const PPP_PexeStreamHandler* stream_handler_;
   void* stream_handler_user_data_;
   bool success_;
   int64_t expected_content_length_;
   base::WeakPtrFactory<PexeDownloader> weak_factory_;
 };
 
@@ skipping 11 matching lines @@
   if (!plugin_instance) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(handler->DidFinishStream, handler_user_data,
                               static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   GURL gurl(pexe_url);
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->document();
-  std::unique_ptr<blink::WebURLLoader> url_loader(
-      CreateWebURLLoader(document, gurl));
+  std::unique_ptr<blink::WebAssociatedURLLoader> url_loader(
+      CreateAssociatedURLLoader(document, gurl));
   PexeDownloader* downloader =
       new PexeDownloader(instance, std::move(url_loader), pexe_url, opt_level,
                          PP_ToBool(use_subzero), handler, handler_user_data);
 
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
   // Mark the request as requesting a PNaCl bitcode file,
   // so that component updater can detect this user action.
   url_request.addHTTPHeaderField(
       blink::WebString::fromUTF8("Accept"),
       blink::WebString::fromUTF8("application/x-pnacl, */*"));
   url_request.setRequestContext(blink::WebURLRequest::RequestContextObject);
   downloader->Load(url_request);
 }
 
 }  // namespace nacl