#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/common/socket_permission_request.h"
+#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/proxy/proxy_info.h"
#include "net/url_request/url_request_context.h"
is_allowed_(false),
waiting_for_ui_thread_data_(true),
weak_factory_(this) {
- int render_process_id(0), render_view_id(0);
- host->GetRenderViewIDsForInstance(instance,
- &render_process_id,
- &render_view_id);
+ int render_process_id(0), render_frame_id(0);
+ host->GetRenderFrameIDsForInstance(
+ instance, &render_process_id, &render_frame_id);
BrowserThread::PostTaskAndReplyWithResult(
- BrowserThread::UI, FROM_HERE,
+ BrowserThread::UI,
+ FROM_HERE,
base::Bind(&GetUIThreadDataOnUIThread,
render_process_id,
- render_view_id,
+ render_frame_id,
host->external_plugin()),
base::Bind(&PepperNetworkProxyHost::DidGetUIThreadData,
weak_factory_.GetWeakPtr()));
}
}
-PepperNetworkProxyHost::UIThreadData::UIThreadData()
- : is_allowed(false) {
-}
+PepperNetworkProxyHost::UIThreadData::UIThreadData() : is_allowed(false) {}
-PepperNetworkProxyHost::UIThreadData::~UIThreadData() {
-}
+PepperNetworkProxyHost::UIThreadData::~UIThreadData() {}
// static
PepperNetworkProxyHost::UIThreadData
PepperNetworkProxyHost::GetUIThreadDataOnUIThread(int render_process_id,
- int render_view_id,
+ int render_frame_id,
bool is_external_plugin) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
PepperNetworkProxyHost::UIThreadData result;
RenderProcessHost* render_process_host =
RenderProcessHost::FromID(render_process_id);
if (render_process_host && render_process_host->GetBrowserContext()) {
- result.context_getter = render_process_host->GetBrowserContext()->
- GetRequestContextForRenderProcess(render_process_id);
+ result.context_getter =
+ render_process_host->GetBrowserContext()
+ ->GetRequestContextForRenderProcess(render_process_id);
}
- RenderViewHost* render_view_host =
- RenderViewHost::FromID(render_process_id, render_view_id);
- if (render_view_host) {
- SocketPermissionRequest request(
- content::SocketPermissionRequest::RESOLVE_PROXY, std::string(), 0);
- result.is_allowed = pepper_socket_utils::CanUseSocketAPIs(
- is_external_plugin,
- false /* is_private_api */,
- &request,
- render_view_host);
- }
+ SocketPermissionRequest request(
+ content::SocketPermissionRequest::RESOLVE_PROXY, std::string(), 0);
+ result.is_allowed =
+ pepper_socket_utils::CanUseSocketAPIs(is_external_plugin,
+ false /* is_private_api */,
+ &request,
+ render_process_id,
+ render_frame_id);
return result;
}
int32_t PepperNetworkProxyHost::OnResourceMessageReceived(
const IPC::Message& msg,
ppapi::host::HostMessageContext* context) {
- IPC_BEGIN_MESSAGE_MAP(PepperNetworkProxyHost, msg)
- PPAPI_DISPATCH_HOST_RESOURCE_CALL(
- PpapiHostMsg_NetworkProxy_GetProxyForURL, OnMsgGetProxyForURL)
- IPC_END_MESSAGE_MAP()
+ PPAPI_BEGIN_MESSAGE_MAP(PepperNetworkProxyHost, msg)
+ PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_NetworkProxy_GetProxyForURL,
+ OnMsgGetProxyForURL)
+ PPAPI_END_MESSAGE_MAP()
return PP_ERROR_FAILED;
}
const std::string& url) {
GURL gurl(url);
if (gurl.is_valid()) {
- UnsentRequest request = { gurl, context->MakeReplyMessageContext() };
+ UnsentRequest request = {gurl, context->MakeReplyMessageContext()};
unsent_requests_.push(request);
TryToSendUnsentRequests();
} else {
- SendFailureReply(PP_ERROR_BADARGUMENT,
- context->MakeReplyMessageContext());
+ SendFailureReply(PP_ERROR_BADARGUMENT, context->MakeReplyMessageContext());
}
return PP_OK_COMPLETIONPENDING;
}
// Everything looks valid, so try to resolve the proxy.
net::ProxyInfo* proxy_info = new net::ProxyInfo;
net::ProxyService::PacRequest* pending_request = NULL;
- base::Callback<void (int)> callback =
+ base::Callback<void(int)> callback =
base::Bind(&PepperNetworkProxyHost::OnResolveProxyCompleted,
weak_factory_.GetWeakPtr(),
request.reply_context,
base::Owned(proxy_info));
int result = proxy_service_->ResolveProxy(request.url,
+ net::LOAD_NORMAL,
proxy_info,
callback,
&pending_request,
+ NULL,
net::BoundNetLog());
pending_requests_.push(pending_request);
// If it was handled synchronously, we must run the callback now;
int32_t error,
ppapi::host::ReplyMessageContext context) {
context.params.set_result(error);
- host()->SendReply(context,
- PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(
- std::string()));
+ host()->SendReply(
+ context, PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(std::string()));
}
} // namespace content