content/browser/renderer_host/pepper/pepper_network_proxy_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/browser/renderer_host/pepper/pepper_network_proxy_host.h"
   6
   7 #include "base/bind.h"
   8 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
   9 #include "content/browser/renderer_host/pepper/pepper_socket_utils.h"
  10 #include "content/public/browser/browser_context.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/public/common/socket_permission_request.h"
  14 #include "net/base/load_flags.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/proxy/proxy_info.h"
  17 #include "net/url_request/url_request_context.h"
  18 #include "net/url_request/url_request_context_getter.h"
  19 #include "ppapi/c/pp_errors.h"
  20 #include "ppapi/host/dispatch_host_message.h"
  21 #include "ppapi/host/ppapi_host.h"
  22 #include "ppapi/proxy/ppapi_messages.h"
  23
  24 namespace content {
  25
  26 PepperNetworkProxyHost::PepperNetworkProxyHost(BrowserPpapiHostImpl* host,
  27                                                PP_Instance instance,
  28                                                PP_Resource resource)
  29     : ResourceHost(host->GetPpapiHost(), instance, resource),
  30       proxy_service_(NULL),
  31       is_allowed_(false),
  32       waiting_for_ui_thread_data_(true),
  33       weak_factory_(this) {
  34   int render_process_id(0), render_frame_id(0);
  35   host->GetRenderFrameIDsForInstance(
  36       instance, &render_process_id, &render_frame_id);
  37   BrowserThread::PostTaskAndReplyWithResult(
  38       BrowserThread::UI,
  39       FROM_HERE,
  40       base::Bind(&GetUIThreadDataOnUIThread,
  41                  render_process_id,
  42                  render_frame_id,
  43                  host->external_plugin()),
  44       base::Bind(&PepperNetworkProxyHost::DidGetUIThreadData,
  45                  weak_factory_.GetWeakPtr()));
  46 }
  47
  48 PepperNetworkProxyHost::~PepperNetworkProxyHost() {
  49   while (!pending_requests_.empty()) {
  50     // If the proxy_service_ is NULL, we shouldn't have any outstanding
  51     // requests.
  52     DCHECK(proxy_service_);
  53     net::ProxyService::PacRequest* request = pending_requests_.front();
  54     proxy_service_->CancelPacRequest(request);
  55     pending_requests_.pop();
  56   }
  57 }
  58
  59 PepperNetworkProxyHost::UIThreadData::UIThreadData() : is_allowed(false) {}
  60
  61 PepperNetworkProxyHost::UIThreadData::~UIThreadData() {}
  62
  63 // static
  64 PepperNetworkProxyHost::UIThreadData
  65 PepperNetworkProxyHost::GetUIThreadDataOnUIThread(int render_process_id,
  66                                                   int render_frame_id,
  67                                                   bool is_external_plugin) {
  68   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  69   PepperNetworkProxyHost::UIThreadData result;
  70   RenderProcessHost* render_process_host =
  71       RenderProcessHost::FromID(render_process_id);
  72   if (render_process_host && render_process_host->GetBrowserContext()) {
  73     result.context_getter =
  74         render_process_host->GetBrowserContext()
  75             ->GetRequestContextForRenderProcess(render_process_id);
  76   }
  77
  78   SocketPermissionRequest request(
  79       content::SocketPermissionRequest::RESOLVE_PROXY, std::string(), 0);
  80   result.is_allowed =
  81       pepper_socket_utils::CanUseSocketAPIs(is_external_plugin,
  82                                             false /* is_private_api */,
  83                                             &request,
  84                                             render_process_id,
  85                                             render_frame_id);
  86   return result;
  87 }
  88
  89 void PepperNetworkProxyHost::DidGetUIThreadData(
  90     const UIThreadData& ui_thread_data) {
  91   is_allowed_ = ui_thread_data.is_allowed;
  92   if (ui_thread_data.context_getter.get() &&
  93       ui_thread_data.context_getter->GetURLRequestContext()) {
  94     proxy_service_ =
  95         ui_thread_data.context_getter->GetURLRequestContext()->proxy_service();
  96   }
  97   waiting_for_ui_thread_data_ = false;
  98   if (!proxy_service_) {
  99     DLOG_IF(WARNING, proxy_service_)
 100         << "Failed to find a ProxyService for Pepper plugin.";
 101   }
 102   TryToSendUnsentRequests();
 103 }
 104
 105 int32_t PepperNetworkProxyHost::OnResourceMessageReceived(
 106     const IPC::Message& msg,
 107     ppapi::host::HostMessageContext* context) {
 108   PPAPI_BEGIN_MESSAGE_MAP(PepperNetworkProxyHost, msg)
 109     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_NetworkProxy_GetProxyForURL,
 110                                       OnMsgGetProxyForURL)
 111   PPAPI_END_MESSAGE_MAP()
 112   return PP_ERROR_FAILED;
 113 }
 114
 115 int32_t PepperNetworkProxyHost::OnMsgGetProxyForURL(
 116     ppapi::host::HostMessageContext* context,
 117     const std::string& url) {
 118   GURL gurl(url);
 119   if (gurl.is_valid()) {
 120     UnsentRequest request = {gurl, context->MakeReplyMessageContext()};
 121     unsent_requests_.push(request);
 122     TryToSendUnsentRequests();
 123   } else {
 124     SendFailureReply(PP_ERROR_BADARGUMENT, context->MakeReplyMessageContext());
 125   }
 126   return PP_OK_COMPLETIONPENDING;
 127 }
 128
 129 void PepperNetworkProxyHost::TryToSendUnsentRequests() {
 130   if (waiting_for_ui_thread_data_)
 131     return;
 132
 133   while (!unsent_requests_.empty()) {
 134     const UnsentRequest& request = unsent_requests_.front();
 135     if (!proxy_service_) {
 136       SendFailureReply(PP_ERROR_FAILED, request.reply_context);
 137     } else if (!is_allowed_) {
 138       SendFailureReply(PP_ERROR_NOACCESS, request.reply_context);
 139     } else {
 140       // Everything looks valid, so try to resolve the proxy.
 141       net::ProxyInfo* proxy_info = new net::ProxyInfo;
 142       net::ProxyService::PacRequest* pending_request = NULL;
 143       base::Callback<void(int)> callback =
 144           base::Bind(&PepperNetworkProxyHost::OnResolveProxyCompleted,
 145                      weak_factory_.GetWeakPtr(),
 146                      request.reply_context,
 147                      base::Owned(proxy_info));
 148       int result = proxy_service_->ResolveProxy(request.url,
 149                                                 net::LOAD_NORMAL,
 150                                                 proxy_info,
 151                                                 callback,
 152                                                 &pending_request,
 153                                                 NULL,
 154                                                 net::BoundNetLog());
 155       pending_requests_.push(pending_request);
 156       // If it was handled synchronously, we must run the callback now;
 157       // proxy_service_ won't run it for us in this case.
 158       if (result != net::ERR_IO_PENDING)
 159         callback.Run(result);
 160     }
 161     unsent_requests_.pop();
 162   }
 163 }
 164
 165 void PepperNetworkProxyHost::OnResolveProxyCompleted(
 166     ppapi::host::ReplyMessageContext context,
 167     net::ProxyInfo* proxy_info,
 168     int result) {
 169   pending_requests_.pop();
 170
 171   if (result != net::OK) {
 172     // Currently, the only proxy-specific error we could get is
 173     // MANDATORY_PROXY_CONFIGURATION_FAILED. There's really no action a plugin
 174     // can take in this case, so there's no need to distinguish it from other
 175     // failures.
 176     context.params.set_result(PP_ERROR_FAILED);
 177   }
 178   host()->SendReply(context,
 179                     PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(
 180                         proxy_info->ToPacString()));
 181 }
 182
 183 void PepperNetworkProxyHost::SendFailureReply(
 184     int32_t error,
 185     ppapi::host::ReplyMessageContext context) {
 186   context.params.set_result(error);
 187   host()->SendReply(
 188       context, PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(std::string()));
 189 }
 190
 191 }  // namespace content