src/content/renderer/pepper/pepper_url_loader_host.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/pepper/pepper_url_loader_host.h"
   6
   7 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
   8 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
   9 #include "content/renderer/pepper/url_request_info_util.h"
  10 #include "content/renderer/pepper/url_response_info_util.h"
  11 #include "net/base/net_errors.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/host/dispatch_host_message.h"
  14 #include "ppapi/host/host_message_context.h"
  15 #include "ppapi/host/ppapi_host.h"
  16 #include "ppapi/proxy/ppapi_messages.h"
  17 #include "ppapi/shared_impl/ppapi_globals.h"
  18 #include "third_party/WebKit/public/platform/WebURLError.h"
  19 #include "third_party/WebKit/public/platform/WebURLLoader.h"
  20 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  21 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  22 #include "third_party/WebKit/public/web/WebDocument.h"
  23 #include "third_party/WebKit/public/web/WebElement.h"
  24 #include "third_party/WebKit/public/web/WebKit.h"
  25 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  26 #include "third_party/WebKit/public/web/WebPluginContainer.h"
  27 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
  28 #include "third_party/WebKit/public/web/WebURLLoaderOptions.h"
  29
  30 using blink::WebLocalFrame;
  31 using blink::WebString;
  32 using blink::WebURL;
  33 using blink::WebURLError;
  34 using blink::WebURLLoader;
  35 using blink::WebURLLoaderOptions;
  36 using blink::WebURLRequest;
  37 using blink::WebURLResponse;
  38
  39 #ifdef _MSC_VER
  40 // Do not warn about use of std::copy with raw pointers.
  41 #pragma warning(disable : 4996)
  42 #endif
  43
  44 namespace content {
  45
  46 PepperURLLoaderHost::PepperURLLoaderHost(RendererPpapiHostImpl* host,
  47                                          bool main_document_loader,
  48                                          PP_Instance instance,
  49                                          PP_Resource resource)
  50     : ResourceHost(host->GetPpapiHost(), instance, resource),
  51       renderer_ppapi_host_(host),
  52       main_document_loader_(main_document_loader),
  53       has_universal_access_(false),
  54       bytes_sent_(0),
  55       total_bytes_to_be_sent_(-1),
  56       bytes_received_(0),
  57       total_bytes_to_be_received_(-1),
  58       pending_response_(false),
  59       weak_factory_(this) {
  60   DCHECK((main_document_loader && !resource) ||
  61          (!main_document_loader && resource));
  62 }
  63
  64 PepperURLLoaderHost::~PepperURLLoaderHost() {
  65   // Normally deleting this object will delete the loader which will implicitly
  66   // cancel the load. But this won't happen for the main document loader. So it
  67   // would be nice to issue a Close() here.
  68   //
  69   // However, the PDF plugin will cancel the document load and then close the
  70   // resource (which is reasonable). It then makes a second request to load the
  71   // document so it can set the "want progress" flags (which is unreasonable --
  72   // we should probably provide download progress on document loads).
  73   //
  74   // But a Close() on the main document (even if the request is already
  75   // canceled) will cancel all pending subresources, of which the second
  76   // request is one, and the load will fail. Even if we fixed the PDF reader to
  77   // change the timing or to send progress events to avoid the second request,
  78   // we don't want to cancel other loads when the main one is closed.
  79   //
  80   // "Leaking" the main document load here by not closing it will only affect
  81   // plugins handling main document loads (which are very few, mostly only PDF)
  82   // that dereference without explicitly closing the main document load (which
  83   // PDF doesn't do -- it explicitly closes it before issuing the second
  84   // request). And the worst thing that will happen is that any remaining data
  85   // will get queued inside WebKit.
  86   if (main_document_loader_) {
  87     // The PluginInstance has a non-owning pointer to us.
  88     PepperPluginInstanceImpl* instance_object =
  89         renderer_ppapi_host_->GetPluginInstanceImpl(pp_instance());
  90     if (instance_object) {
  91       DCHECK(instance_object->document_loader() == this);
  92       instance_object->set_document_loader(NULL);
  93     }
  94   }
  95
  96   // There is a path whereby the destructor for the loader_ member can
  97   // invoke InstanceWasDeleted() upon this URLLoaderResource, thereby
  98   // re-entering the scoped_ptr destructor with the same scoped_ptr object
  99   // via loader_.reset(). Be sure that loader_ is first NULL then destroy
 100   // the scoped_ptr. See http://crbug.com/159429.
 101   scoped_ptr<blink::WebURLLoader> for_destruction_only(loader_.release());
 102 }
 103
 104 int32_t PepperURLLoaderHost::OnResourceMessageReceived(
 105     const IPC::Message& msg,
 106     ppapi::host::HostMessageContext* context) {
 107   IPC_BEGIN_MESSAGE_MAP(PepperURLLoaderHost, msg)
 108   PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_URLLoader_Open, OnHostMsgOpen)
 109   PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_URLLoader_SetDeferLoading,
 110                                     OnHostMsgSetDeferLoading)
 111   PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_URLLoader_Close,
 112                                       OnHostMsgClose);
 113   PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
 114       PpapiHostMsg_URLLoader_GrantUniversalAccess,
 115       OnHostMsgGrantUniversalAccess)
 116   IPC_END_MESSAGE_MAP()
 117   return PP_ERROR_FAILED;
 118 }
 119
 120 void PepperURLLoaderHost::willSendRequest(
 121     WebURLLoader* loader,
 122     WebURLRequest& new_request,
 123     const WebURLResponse& redirect_response) {
 124   DCHECK(out_of_order_replies_.empty());
 125   if (!request_data_.follow_redirects) {
 126     SaveResponse(redirect_response);
 127     SetDefersLoading(true);
 128   }
 129 }
 130
 131 void PepperURLLoaderHost::didSendData(
 132     WebURLLoader* loader,
 133     unsigned long long bytes_sent,
 134     unsigned long long total_bytes_to_be_sent) {
 135   // TODO(darin): Bounds check input?
 136   bytes_sent_ = static_cast<int64_t>(bytes_sent);
 137   total_bytes_to_be_sent_ = static_cast<int64_t>(total_bytes_to_be_sent);
 138   UpdateProgress();
 139 }
 140
 141 void PepperURLLoaderHost::didReceiveResponse(WebURLLoader* loader,
 142                                              const WebURLResponse& response) {
 143   // Sets -1 if the content length is unknown. Send before issuing callback.
 144   total_bytes_to_be_received_ = response.expectedContentLength();
 145   UpdateProgress();
 146
 147   SaveResponse(response);
 148 }
 149
 150 void PepperURLLoaderHost::didDownloadData(WebURLLoader* loader,
 151                                           int data_length,
 152                                           int encoded_data_length) {
 153   bytes_received_ += data_length;
 154   UpdateProgress();
 155 }
 156
 157 void PepperURLLoaderHost::didReceiveData(WebURLLoader* loader,
 158                                          const char* data,
 159                                          int data_length,
 160                                          int encoded_data_length) {
 161   // Note that |loader| will be NULL for document loads.
 162   bytes_received_ += data_length;
 163   UpdateProgress();
 164
 165   PpapiPluginMsg_URLLoader_SendData* message =
 166       new PpapiPluginMsg_URLLoader_SendData;
 167   message->WriteData(data, data_length);
 168   SendUpdateToPlugin(message);
 169 }
 170
 171 void PepperURLLoaderHost::didFinishLoading(WebURLLoader* loader,
 172                                            double finish_time,
 173                                            int64_t total_encoded_data_length) {
 174   // Note that |loader| will be NULL for document loads.
 175   SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(PP_OK));
 176 }
 177
 178 void PepperURLLoaderHost::didFail(WebURLLoader* loader,
 179                                   const WebURLError& error) {
 180   // Note that |loader| will be NULL for document loads.
 181   int32_t pp_error = PP_ERROR_FAILED;
 182   if (error.domain.equals(WebString::fromUTF8(net::kErrorDomain))) {
 183     // TODO(bbudge): Extend pp_errors.h to cover interesting network errors
 184     // from the net error domain.
 185     switch (error.reason) {
 186       case net::ERR_ACCESS_DENIED:
 187       case net::ERR_NETWORK_ACCESS_DENIED:
 188         pp_error = PP_ERROR_NOACCESS;
 189         break;
 190     }
 191   } else {
 192     // It's a WebKit error.
 193     pp_error = PP_ERROR_NOACCESS;
 194   }
 195   SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(pp_error));
 196 }
 197
 198 void PepperURLLoaderHost::DidConnectPendingHostToResource() {
 199   for (size_t i = 0; i < pending_replies_.size(); i++)
 200     host()->SendUnsolicitedReply(pp_resource(), *pending_replies_[i]);
 201   pending_replies_.clear();
 202 }
 203
 204 int32_t PepperURLLoaderHost::OnHostMsgOpen(
 205     ppapi::host::HostMessageContext* context,
 206     const ppapi::URLRequestInfoData& request_data) {
 207   // An "Open" isn't a resource Call so has no reply, but failure to open
 208   // implies a load failure. To make it harder to forget to send the load
 209   // failed reply from the open handler, we instead catch errors and convert
 210   // them to load failed messages.
 211   int32_t ret = InternalOnHostMsgOpen(context, request_data);
 212   DCHECK(ret != PP_OK_COMPLETIONPENDING);
 213
 214   if (ret != PP_OK)
 215     SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(ret));
 216   return PP_OK;
 217 }
 218
 219 // Since this is wrapped by OnHostMsgOpen, we can return errors here and they
 220 // will be translated into a FinishedLoading call automatically.
 221 int32_t PepperURLLoaderHost::InternalOnHostMsgOpen(
 222     ppapi::host::HostMessageContext* context,
 223     const ppapi::URLRequestInfoData& request_data) {
 224   // Main document loads are already open, so don't allow people to open them
 225   // again.
 226   if (main_document_loader_)
 227     return PP_ERROR_INPROGRESS;
 228
 229   // Create a copy of the request data since CreateWebURLRequest will populate
 230   // the file refs.
 231   ppapi::URLRequestInfoData filled_in_request_data = request_data;
 232
 233   if (URLRequestRequiresUniversalAccess(filled_in_request_data) &&
 234       !has_universal_access_) {
 235     ppapi::PpapiGlobals::Get()->LogWithSource(
 236         pp_instance(),
 237         PP_LOGLEVEL_ERROR,
 238         std::string(),
 239         "PPB_URLLoader.Open: The URL you're requesting is "
 240         " on a different security origin than your plugin. To request "
 241         " cross-origin resources, see "
 242         " PP_URLREQUESTPROPERTY_ALLOWCROSSORIGINREQUESTS.");
 243     return PP_ERROR_NOACCESS;
 244   }
 245
 246   if (loader_.get())
 247     return PP_ERROR_INPROGRESS;
 248
 249   WebLocalFrame* frame = GetFrame();
 250   if (!frame)
 251     return PP_ERROR_FAILED;
 252
 253   WebURLRequest web_request;
 254   if (!CreateWebURLRequest(
 255           pp_instance(), &filled_in_request_data, frame, &web_request)) {
 256     return PP_ERROR_FAILED;
 257   }
 258
 259   web_request.setTargetType(WebURLRequest::TargetIsObject);
 260   web_request.setRequestorProcessID(renderer_ppapi_host_->GetPluginPID());
 261
 262   WebURLLoaderOptions options;
 263   if (has_universal_access_) {
 264     options.allowCredentials = true;
 265     options.crossOriginRequestPolicy =
 266         WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
 267   } else {
 268     // All other HTTP requests are untrusted.
 269     options.untrustedHTTP = true;
 270     if (filled_in_request_data.allow_cross_origin_requests) {
 271       // Allow cross-origin requests with access control. The request specifies
 272       // if credentials are to be sent.
 273       options.allowCredentials = filled_in_request_data.allow_credentials;
 274       options.crossOriginRequestPolicy =
 275           WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
 276     } else {
 277       // Same-origin requests can always send credentials.
 278       options.allowCredentials = true;
 279     }
 280   }
 281
 282   loader_.reset(frame->createAssociatedURLLoader(options));
 283   if (!loader_.get())
 284     return PP_ERROR_FAILED;
 285
 286   // Don't actually save the request until we know we're going to load.
 287   request_data_ = filled_in_request_data;
 288   loader_->loadAsynchronously(web_request, this);
 289
 290   // Although the request is technically pending, this is not a "Call" message
 291   // so we don't return COMPLETIONPENDING.
 292   return PP_OK;
 293 }
 294
 295 int32_t PepperURLLoaderHost::OnHostMsgSetDeferLoading(
 296     ppapi::host::HostMessageContext* context,
 297     bool defers_loading) {
 298   SetDefersLoading(defers_loading);
 299   return PP_OK;
 300 }
 301
 302 int32_t PepperURLLoaderHost::OnHostMsgClose(
 303     ppapi::host::HostMessageContext* context) {
 304   Close();
 305   return PP_OK;
 306 }
 307
 308 int32_t PepperURLLoaderHost::OnHostMsgGrantUniversalAccess(
 309     ppapi::host::HostMessageContext* context) {
 310   // Only plugins with private permission can bypass same origin.
 311   if (!host()->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
 312     return PP_ERROR_FAILED;
 313   has_universal_access_ = true;
 314   return PP_OK;
 315 }
 316
 317 void PepperURLLoaderHost::SendUpdateToPlugin(IPC::Message* message) {
 318   // We must send messages to the plugin in the order that the responses are
 319   // received from webkit, even when the host isn't ready to send messages or
 320   // when the host performs an asynchronous operation.
 321   //
 322   // Only {FinishedLoading, ReceivedResponse, SendData} have ordering
 323   // contraints; all other messages are immediately added to pending_replies_.
 324   //
 325   // Accepted orderings for {FinishedLoading, ReceivedResponse, SendData} are:
 326   //   - {ReceivedResponse, SendData (zero or more times), FinishedLoading}
 327   //   - {FinishedLoading (when status != PP_OK)}
 328   if (message->type() == PpapiPluginMsg_URLLoader_SendData::ID ||
 329       message->type() == PpapiPluginMsg_URLLoader_FinishedLoading::ID) {
 330     // Messages that must be sent after ReceivedResponse.
 331     if (pending_response_) {
 332       out_of_order_replies_.push_back(message);
 333     } else {
 334       SendOrderedUpdateToPlugin(message);
 335     }
 336   } else if (message->type() == PpapiPluginMsg_URLLoader_ReceivedResponse::ID) {
 337     // Allow SendData and FinishedLoading into the ordered queue.
 338     DCHECK(pending_response_);
 339     SendOrderedUpdateToPlugin(message);
 340     for (size_t i = 0; i < out_of_order_replies_.size(); i++)
 341       SendOrderedUpdateToPlugin(out_of_order_replies_[i]);
 342     // SendOrderedUpdateToPlugin destroys the messages for us.
 343     out_of_order_replies_.weak_clear();
 344     pending_response_ = false;
 345   } else {
 346     // Messages without ordering constraints.
 347     SendOrderedUpdateToPlugin(message);
 348   }
 349 }
 350
 351 void PepperURLLoaderHost::SendOrderedUpdateToPlugin(IPC::Message* message) {
 352   if (pp_resource() == 0) {
 353     pending_replies_.push_back(message);
 354   } else {
 355     host()->SendUnsolicitedReply(pp_resource(), *message);
 356     delete message;
 357   }
 358 }
 359
 360 void PepperURLLoaderHost::Close() {
 361   if (loader_.get())
 362     loader_->cancel();
 363   else if (main_document_loader_)
 364     GetFrame()->stopLoading();
 365 }
 366
 367 blink::WebLocalFrame* PepperURLLoaderHost::GetFrame() {
 368   PepperPluginInstance* instance_object =
 369       renderer_ppapi_host_->GetPluginInstance(pp_instance());
 370   if (!instance_object)
 371     return NULL;
 372   return instance_object->GetContainer()->element().document().frame();
 373 }
 374
 375 void PepperURLLoaderHost::SetDefersLoading(bool defers_loading) {
 376   if (loader_.get())
 377     loader_->setDefersLoading(defers_loading);
 378
 379   // TODO(brettw) bug 96770: We need a way to set the defers loading flag on
 380   // main document loads (when the loader_ is null).
 381 }
 382
 383 void PepperURLLoaderHost::SaveResponse(const WebURLResponse& response) {
 384   // When we're the main document loader, we send the response data up front,
 385   // so we don't want to trigger any callbacks in the plugin which aren't
 386   // expected. We should not be getting redirects so the response sent
 387   // up-front should be valid (plugin document loads happen after all
 388   // redirects are processed since WebKit has to know the MIME type).
 389   if (!main_document_loader_) {
 390     // We note when there's a callback in flight for a response to ensure that
 391     // messages we send to the plugin are not sent out of order. See
 392     // SendUpdateToPlugin() for more details.
 393     DCHECK(!pending_response_);
 394     pending_response_ = true;
 395
 396     DataFromWebURLResponse(
 397         renderer_ppapi_host_,
 398         pp_instance(),
 399         response,
 400         base::Bind(&PepperURLLoaderHost::DidDataFromWebURLResponse,
 401                    weak_factory_.GetWeakPtr()));
 402   }
 403 }
 404
 405 void PepperURLLoaderHost::DidDataFromWebURLResponse(
 406     const ppapi::URLResponseInfoData& data) {
 407   SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_ReceivedResponse(data));
 408 }
 409
 410 void PepperURLLoaderHost::UpdateProgress() {
 411   bool record_download = request_data_.record_download_progress;
 412   bool record_upload = request_data_.record_upload_progress;
 413   if (record_download || record_upload) {
 414     // Here we go through some effort to only send the exact information that
 415     // the requestor wanted in the request flags. It would be just as
 416     // efficient to send all of it, but we don't want people to rely on
 417     // getting download progress when they happen to set the upload progress
 418     // flag.
 419     ppapi::proxy::ResourceMessageReplyParams params;
 420     SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_UpdateProgress(
 421         record_upload ? bytes_sent_ : -1,
 422         record_upload ? total_bytes_to_be_sent_ : -1,
 423         record_download ? bytes_received_ : -1,
 424         record_download ? total_bytes_to_be_received_ : -1));
 425   }
 426 }
 427
 428 }  // namespace content