content/browser/renderer_host/pepper/pepper_network_proxy_host.cc

   1 // Copyright 2013 The Chromium Authors
   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 "base/logging.h"
   9 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
  10 #include "content/browser/renderer_host/pepper/pepper_proxy_lookup_helper.h"
  11 #include "content/browser/renderer_host/pepper/pepper_socket_utils.h"
  12 #include "content/public/browser/browser_context.h"
  13 #include "content/public/browser/browser_task_traits.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/browser/render_frame_host.h"
  16 #include "content/public/browser/render_process_host.h"
  17 #include "content/public/browser/site_instance.h"
  18 #include "content/public/browser/storage_partition.h"
  19 #include "content/public/common/socket_permission_request.h"
  20 #include "mojo/public/cpp/bindings/pending_remote.h"
  21 #include "net/base/network_isolation_key.h"
  22 #include "net/proxy_resolution/proxy_info.h"
  23 #include "ppapi/c/pp_errors.h"
  24 #include "ppapi/host/dispatch_host_message.h"
  25 #include "ppapi/host/ppapi_host.h"
  26 #include "ppapi/proxy/ppapi_messages.h"
  27 #include "services/network/public/mojom/network_context.mojom.h"
  28 #include "services/network/public/mojom/proxy_lookup_client.mojom.h"
  29
  30 namespace content {
  31
  32 namespace {
  33
  34 bool LookUpProxyForURLCallback(
  35     int render_process_host_id,
  36     int render_frame_host_id,
  37     const GURL& url,
  38     mojo::PendingRemote<network::mojom::ProxyLookupClient>
  39         proxy_lookup_client) {
  40   RenderFrameHost* render_frame_host =
  41       RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
  42   if (!render_frame_host)
  43     return false;
  44
  45   SiteInstance* site_instance = render_frame_host->GetSiteInstance();
  46   StoragePartition* storage_partition =
  47       site_instance->GetBrowserContext()->GetStoragePartition(site_instance);
  48
  49   storage_partition->GetNetworkContext()->LookUpProxyForURL(
  50       url,
  51       render_frame_host->GetIsolationInfoForSubresources()
  52           .network_anonymization_key(),
  53       std::move(proxy_lookup_client));
  54   return true;
  55 }
  56
  57 }  // namespace
  58
  59 PepperNetworkProxyHost::PepperNetworkProxyHost(BrowserPpapiHostImpl* host,
  60                                                PP_Instance instance,
  61                                                PP_Resource resource)
  62     : ResourceHost(host->GetPpapiHost(), instance, resource),
  63       render_process_id_(0),
  64       render_frame_id_(0),
  65       is_allowed_(false),
  66       waiting_for_ui_thread_data_(true) {
  67   host->GetRenderFrameIDsForInstance(instance, &render_process_id_,
  68                                      &render_frame_id_);
  69   GetUIThreadTaskRunner({})->PostTaskAndReplyWithResult(
  70       FROM_HERE,
  71       base::BindOnce(&GetUIThreadDataOnUIThread, render_process_id_,
  72                      render_frame_id_, host->external_plugin()),
  73       base::BindOnce(&PepperNetworkProxyHost::DidGetUIThreadData,
  74                      weak_factory_.GetWeakPtr()));
  75 }
  76
  77 PepperNetworkProxyHost::~PepperNetworkProxyHost() = default;
  78
  79 PepperNetworkProxyHost::UIThreadData::UIThreadData() : is_allowed(false) {}
  80
  81 PepperNetworkProxyHost::UIThreadData::UIThreadData(const UIThreadData& other) =
  82     default;
  83
  84 PepperNetworkProxyHost::UIThreadData::~UIThreadData() {}
  85
  86 // static
  87 PepperNetworkProxyHost::UIThreadData
  88 PepperNetworkProxyHost::GetUIThreadDataOnUIThread(int render_process_id,
  89                                                   int render_frame_id,
  90                                                   bool is_external_plugin) {
  91   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  92   PepperNetworkProxyHost::UIThreadData result;
  93
  94   SocketPermissionRequest request(
  95       content::SocketPermissionRequest::RESOLVE_PROXY, std::string(), 0);
  96   result.is_allowed =
  97       pepper_socket_utils::CanUseSocketAPIs(is_external_plugin,
  98                                             false /* is_private_api */,
  99                                             &request,
 100                                             render_process_id,
 101                                             render_frame_id);
 102   return result;
 103 }
 104
 105 void PepperNetworkProxyHost::DidGetUIThreadData(
 106     const UIThreadData& ui_thread_data) {
 107   is_allowed_ = ui_thread_data.is_allowed;
 108   waiting_for_ui_thread_data_ = false;
 109   TryToSendUnsentRequests();
 110 }
 111
 112 int32_t PepperNetworkProxyHost::OnResourceMessageReceived(
 113     const IPC::Message& msg,
 114     ppapi::host::HostMessageContext* context) {
 115   PPAPI_BEGIN_MESSAGE_MAP(PepperNetworkProxyHost, msg)
 116     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_NetworkProxy_GetProxyForURL,
 117                                       OnMsgGetProxyForURL)
 118   PPAPI_END_MESSAGE_MAP()
 119   LOG(ERROR) << "Resource message not resolved";
 120   return PP_ERROR_FAILED;
 121 }
 122
 123 int32_t PepperNetworkProxyHost::OnMsgGetProxyForURL(
 124     ppapi::host::HostMessageContext* context,
 125     const std::string& url) {
 126   GURL gurl(url);
 127   if (gurl.is_valid()) {
 128     UnsentRequest request = {gurl, context->MakeReplyMessageContext()};
 129     unsent_requests_.push(request);
 130     TryToSendUnsentRequests();
 131   } else {
 132     SendFailureReply(PP_ERROR_BADARGUMENT, context->MakeReplyMessageContext());
 133   }
 134   return PP_OK_COMPLETIONPENDING;
 135 }
 136
 137 void PepperNetworkProxyHost::TryToSendUnsentRequests() {
 138   if (waiting_for_ui_thread_data_)
 139     return;
 140
 141   while (!unsent_requests_.empty()) {
 142     const UnsentRequest& request = unsent_requests_.front();
 143     if (!is_allowed_) {
 144       SendFailureReply(PP_ERROR_NOACCESS, request.reply_context);
 145     } else {
 146       // Everything looks valid, so try to resolve the proxy.
 147       auto lookup_helper = std::make_unique<PepperProxyLookupHelper>();
 148       PepperProxyLookupHelper::LookUpProxyForURLCallback
 149           look_up_proxy_for_url_callback = base::BindOnce(
 150               &LookUpProxyForURLCallback, render_process_id_, render_frame_id_);
 151       PepperProxyLookupHelper::LookUpCompleteCallback
 152           look_up_complete_callback =
 153               base::BindOnce(&PepperNetworkProxyHost::OnResolveProxyCompleted,
 154                              weak_factory_.GetWeakPtr(), request.reply_context,
 155                              lookup_helper.get());
 156       lookup_helper->Start(request.url,
 157                            std::move(look_up_proxy_for_url_callback),
 158                            std::move(look_up_complete_callback));
 159       pending_requests_.insert(std::move(lookup_helper));
 160     }
 161     unsent_requests_.pop();
 162   }
 163 }
 164
 165 void PepperNetworkProxyHost::OnResolveProxyCompleted(
 166     ppapi::host::ReplyMessageContext context,
 167     PepperProxyLookupHelper* pending_request,
 168     absl::optional<net::ProxyInfo> proxy_info) {
 169   auto it = pending_requests_.find(pending_request);
 170   DCHECK(it != pending_requests_.end());
 171   pending_requests_.erase(it);
 172
 173   std::string pac_string;
 174   if (!proxy_info) {
 175     // This can happen in cases of network service crash, shutdown, or when
 176     // the request fails with ERR_MANDATORY_PROXY_CONFIGURATION_FAILED. There's
 177     // really no action a plugin can take, so there's no need to distinguish
 178     // which error occurred.
 179     context.params.set_result(PP_ERROR_FAILED);
 180   } else {
 181     pac_string = proxy_info->ToPacString();
 182   }
 183   host()->SendReply(
 184       context, PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(pac_string));
 185 }
 186
 187 void PepperNetworkProxyHost::SendFailureReply(
 188     int32_t error,
 189     ppapi::host::ReplyMessageContext context) {
 190   context.params.set_result(error);
 191   host()->SendReply(
 192       context, PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(std::string()));
 193 }
 194
 195 }  // namespace content