Make PepperWebPlugin not use RenderViews.

content/browser/renderer_host/pepper/pepper_network_proxy_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/browser/renderer_host/pepper/pepper_network_proxy_host.h"
 
 #include "base/bind.h"
 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 #include "content/browser/renderer_host/pepper/pepper_socket_utils.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 12 matching lines @@
 namespace content {
 
 PepperNetworkProxyHost::PepperNetworkProxyHost(BrowserPpapiHostImpl* host,
                                                PP_Instance instance,
                                                PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       proxy_service_(NULL),
       is_allowed_(false),
       waiting_for_ui_thread_data_(true),
       weak_factory_(this) {
-  int render_process_id(0), render_view_id(0);
-  host->GetRenderViewIDsForInstance(instance,
+  int render_process_id(0), render_frame_id(0);
+  host->GetRenderFrameIDsForInstance(instance,
                                     &render_process_id,
-                                    &render_view_id);
+                                    &render_frame_id);
   BrowserThread::PostTaskAndReplyWithResult(
       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::~PepperNetworkProxyHost() {
   while (!pending_requests_.empty()) {
     // If the proxy_service_ is NULL, we shouldn't have any outstanding
     // requests.
     DCHECK(proxy_service_);
     net::ProxyService::PacRequest* request = pending_requests_.front();
     proxy_service_->CancelPacRequest(request);
     pending_requests_.pop();
   }
 }
 
 PepperNetworkProxyHost::UIThreadData::UIThreadData()
     : is_allowed(false) {
 }
 
 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));
   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);
   }
 
-  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;
 }
 
 void PepperNetworkProxyHost::DidGetUIThreadData(
     const UIThreadData& ui_thread_data) {
   is_allowed_ = ui_thread_data.is_allowed;
   if (ui_thread_data.context_getter.get() &&
       ui_thread_data.context_getter->GetURLRequestContext()) {
     proxy_service_ =
         ui_thread_data.context_getter->GetURLRequestContext()->proxy_service();
@@ skipping 86 matching lines @@
 void PepperNetworkProxyHost::SendFailureReply(
     int32_t error,
     ppapi::host::ReplyMessageContext context) {
   context.params.set_result(error);
   host()->SendReply(context,
                     PpapiPluginMsg_NetworkProxy_GetProxyForURLReply(
                         std::string()));
 }
 
 }  // namespace content