AssociatedURLLoader shouldn't derive from WebURLLoader

content/renderer/pepper/pepper_url_loader_host.cc

 // Copyright (c) 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 "content/renderer/pepper/pepper_url_loader_host.h"
 
 #include <stddef.h>
 
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/pepper/url_request_info_util.h"
 #include "content/renderer/pepper/url_response_info_util.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebURLError.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/WebAssociatedURLLoaderOptions.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebKit.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"
 
+using blink::WebAssociatedURLLoader;
+using blink::WebAssociatedURLLoaderOptions;
 using blink::WebLocalFrame;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebURLError;
-using blink::WebURLLoader;
-using blink::WebURLLoaderOptions;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 namespace content {
 
@@ skipping 45 matching lines @@
       DCHECK(instance_object->document_loader() == this);
       instance_object->set_document_loader(NULL);
     }
   }
 
   // There is a path whereby the destructor for the loader_ member can
   // invoke InstanceWasDeleted() upon this URLLoaderResource, thereby
   // re-entering the scoped_ptr destructor with the same scoped_ptr object
   // via loader_.reset(). Be sure that loader_ is first NULL then destroy
   // the scoped_ptr. See http://crbug.com/159429.
-  std::unique_ptr<blink::WebURLLoader> for_destruction_only(loader_.release());
+  std::unique_ptr<WebAssociatedURLLoader> for_destruction_only(
+      loader_.release());
 }
 
 int32_t PepperURLLoaderHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   PPAPI_BEGIN_MESSAGE_MAP(PepperURLLoaderHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_URLLoader_Open,
                                       OnHostMsgOpen)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_URLLoader_SetDeferLoading,
                                       OnHostMsgSetDeferLoading)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_URLLoader_Close,
                                         OnHostMsgClose);
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
         PpapiHostMsg_URLLoader_GrantUniversalAccess,
         OnHostMsgGrantUniversalAccess)
   PPAPI_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 bool PepperURLLoaderHost::willFollowRedirect(
-    WebURLLoader* loader,
-    WebURLRequest& new_request,
+    const WebURLRequest& new_request,
     const WebURLResponse& redirect_response) {
   DCHECK(out_of_order_replies_.empty());
   if (!request_data_.follow_redirects) {
     SaveResponse(redirect_response);
     SetDefersLoading(true);
     // Defer the request and wait the plugin to audit the redirect. We
     // shouldn't return false here as decision has been delegated to the
     // plugin.
   }
   return true;
 }
 
 void PepperURLLoaderHost::didSendData(
-    WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   // TODO(darin): Bounds check input?
   bytes_sent_ = static_cast<int64_t>(bytes_sent);
   total_bytes_to_be_sent_ = static_cast<int64_t>(total_bytes_to_be_sent);
   UpdateProgress();
 }
 
-void PepperURLLoaderHost::didReceiveResponse(WebURLLoader* loader,
-                                             const WebURLResponse& response) {
+void PepperURLLoaderHost::didReceiveResponse(const WebURLResponse& response) {
   // Sets -1 if the content length is unknown. Send before issuing callback.
   total_bytes_to_be_received_ = response.expectedContentLength();
   UpdateProgress();
 
   SaveResponse(response);
 }
 
-void PepperURLLoaderHost::didDownloadData(WebURLLoader* loader,
-                                          int data_length,
-                                          int encoded_data_length) {
+void PepperURLLoaderHost::didDownloadData(int data_length) {
   bytes_received_ += data_length;
   UpdateProgress();
 }
 
-void PepperURLLoaderHost::didReceiveData(WebURLLoader* loader,
-                                         const char* data,
-                                         int data_length,
-                                         int encoded_data_length,
-                                         int encoded_body_length) {
+void PepperURLLoaderHost::didReceiveData(const char* data, int data_length) {
   // Note that |loader| will be NULL for document loads.
   bytes_received_ += data_length;
   UpdateProgress();
 
   PpapiPluginMsg_URLLoader_SendData* message =
       new PpapiPluginMsg_URLLoader_SendData;
   message->WriteData(data, data_length);
   SendUpdateToPlugin(message);
 }
 
-void PepperURLLoaderHost::didFinishLoading(WebURLLoader* loader,
-                                           double finish_time,
-                                           int64_t total_encoded_data_length) {
+void PepperURLLoaderHost::didFinishLoading(double finish_time) {
   // Note that |loader| will be NULL for document loads.
   SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(PP_OK));
 }
 
-void PepperURLLoaderHost::didFail(WebURLLoader* loader,
-                                  const WebURLError& error) {
+void PepperURLLoaderHost::didFail(const WebURLError& error) {
   // Note that |loader| will be NULL for document loads.
   int32_t pp_error = PP_ERROR_FAILED;
   if (error.domain.equals(WebString::fromUTF8(net::kErrorDomain))) {
     // TODO(bbudge): Extend pp_errors.h to cover interesting network errors
     // from the net error domain.
     switch (error.reason) {
       case net::ERR_ACCESS_DENIED:
       case net::ERR_NETWORK_ACCESS_DENIED:
         pp_error = PP_ERROR_NOACCESS;
         break;
@@ skipping 65 matching lines @@
           pp_instance(), &filled_in_request_data, frame, &web_request)) {
     return PP_ERROR_FAILED;
   }
 
   web_request.setRequestContext(WebURLRequest::RequestContextPlugin);
   web_request.setRequestorProcessID(renderer_ppapi_host_->GetPluginPID());
   // The requests from the plugins with private permission which can bypass same
   // origin must skip the ServiceWorker.
   web_request.setSkipServiceWorker(
       host()->permissions().HasPermission(ppapi::PERMISSION_PRIVATE)
-          ? blink::WebURLRequest::SkipServiceWorker::All
-          : blink::WebURLRequest::SkipServiceWorker::None);
+          ? WebURLRequest::SkipServiceWorker::All
+          : WebURLRequest::SkipServiceWorker::None);
 
-  WebURLLoaderOptions options;
+  WebAssociatedURLLoaderOptions options;
   if (has_universal_access_) {
     options.allowCredentials = true;
     options.crossOriginRequestPolicy =
-        WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
+        WebAssociatedURLLoaderOptions::CrossOriginRequestPolicyAllow;
   } else {
     // All other HTTP requests are untrusted.
     options.untrustedHTTP = true;
     if (filled_in_request_data.allow_cross_origin_requests) {
       // Allow cross-origin requests with access control. The request specifies
       // if credentials are to be sent.
       options.allowCredentials = filled_in_request_data.allow_credentials;
-      options.crossOriginRequestPolicy =
-          WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
+      options.crossOriginRequestPolicy = WebAssociatedURLLoaderOptions::
+          CrossOriginRequestPolicyUseAccessControl;
     } else {
       // Same-origin requests can always send credentials.
       options.allowCredentials = true;
     }
   }
 
   loader_.reset(frame->createAssociatedURLLoader(options));
   if (!loader_.get())
     return PP_ERROR_FAILED;
 
@@ skipping 73 matching lines @@
 
 void PepperURLLoaderHost::Close() {
   if (loader_.get()) {
     loader_->cancel();
   } else if (main_document_loader_) {
     // TODO(raymes): Calling WebLocalFrame::stopLoading here is incorrect as it
     // cancels all URL loaders associated with the frame. If a client has opened
     // other URLLoaders and then closes the main one, the others should still
     // remain connected. Work out how to only cancel the main request:
     // crbug.com/384197.
-    blink::WebLocalFrame* frame = GetFrame();
+    WebLocalFrame* frame = GetFrame();
     if (frame)
       frame->stopLoading();
   }
 }
 
-blink::WebLocalFrame* PepperURLLoaderHost::GetFrame() {
+WebLocalFrame* PepperURLLoaderHost::GetFrame() {
   PepperPluginInstanceImpl* instance_object =
       static_cast<PepperPluginInstanceImpl*>(
           renderer_ppapi_host_->GetPluginInstance(pp_instance()));
   if (!instance_object || instance_object->is_deleted())
     return NULL;
   return instance_object->GetContainer()->document().frame();
 }
 
 void PepperURLLoaderHost::SetDefersLoading(bool defers_loading) {
   if (loader_.get())
@@ skipping 42 matching lines @@
     ppapi::proxy::ResourceMessageReplyParams params;
     SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_UpdateProgress(
         record_upload ? bytes_sent_ : -1,
         record_upload ? total_bytes_to_be_sent_ : -1,
         record_download ? bytes_received_ : -1,
         record_download ? total_bytes_to_be_received_ : -1));
   }
 }
 
 }  // namespace content