Load NPAPI plugin resources through the browser process directly instead of going through the render

content/renderer/npapi/webplugin_delegate_proxy.cc

 // Copyright (c) 2012 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/renderer/npapi/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #elif defined(USE_X11)
 #include <cairo/cairo.h>
@@ skipping 10 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "base/process/process.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "content/child/child_process.h"
 #include "content/child/npapi/npobject_proxy.h"
 #include "content/child/npapi/npobject_stub.h"
 #include "content/child/npapi/npobject_util.h"
-#include "content/child/npapi/webplugin.h"
 #include "content/child/npapi/webplugin_resource_client.h"
 #include "content/child/plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/view_messages.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/npapi/plugin_channel_host.h"
+#include "content/renderer/npapi/webplugin_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/sad_plugin.h"
 #include "ipc/ipc_channel_handle.h"
 #include "net/base/mime_util.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
@@ skipping 146 matching lines @@
   int instance_id_;
   unsigned long resource_id_;
   // Set to true if the response expected is a multibyte response.
   // For e.g. response for a HTTP byte range request.
   bool multibyte_response_expected_;
 };
 
 }  // namespace
 
 WebPluginDelegateProxy::WebPluginDelegateProxy(
+    WebPluginImpl* plugin,
     const std::string& mime_type,
     const base::WeakPtr<RenderViewImpl>& render_view)
     : render_view_(render_view),
-      plugin_(NULL),
+      plugin_(plugin),
       uses_shared_bitmaps_(false),
 #if defined(OS_MACOSX)
       uses_compositor_(false),
 #elif defined(OS_WIN)
       dummy_activation_window_(NULL),
 #endif
       window_(gfx::kNullPluginWindow),
       mime_type_(mime_type),
       instance_id_(MSG_ROUTING_NONE),
       npobject_(NULL),
@@ skipping 59 matching lines @@
 
   plugin_ = NULL;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 bool WebPluginDelegateProxy::Initialize(
     const GURL& url,
     const std::vector<std::string>& arg_names,
     const std::vector<std::string>& arg_values,
-    WebPlugin* plugin,
     bool load_manually) {
   // TODO(shess): Attempt to work around http://crbug.com/97285 and
   // http://crbug.com/141055 by retrying the connection.  Reports seem
   // to indicate that the plugin hasn't crashed, and that the problem
   // is not 100% persistent.
   const size_t kAttempts = 2;
 
   bool result = false;
   scoped_refptr<PluginChannelHost> channel_host;
   int instance_id = 0;
@@ skipping 68 matching lines @@
 
   // Now tell the PluginInstance in the plugin process to initialize.
   PluginMsg_Init_Params params;
   params.url = url;
   params.page_url = page_url_;
   params.arg_names = arg_names;
   params.arg_values = arg_values;
   params.host_render_view_routing_id = render_view_->routing_id();
   params.load_manually = load_manually;
 
-  plugin_ = plugin;
-
   result = false;
   Send(new PluginMsg_Init(instance_id_, params, &transparent_, &result));
 
   if (!result)
     LOG(WARNING) << "PluginMsg_Init returned false";
 
   render_view_->RegisterPluginDelegate(this);
 
   return result;
 }
@@ skipping 45 matching lines @@
 void WebPluginDelegateProxy::DidManualLoadFail() {
   Send(new PluginMsg_DidManualLoadFail(instance_id_));
 }
 
 bool WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
   GetContentClient()->SetActiveURL(page_url_);
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
-#if defined(OS_WIN)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessData, OnSetWindowlessData)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_NotifyIMEStatus, OnNotifyIMEStatus)
-#endif
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelResource, OnCancelResource)
     IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject,
                         OnGetWindowScriptNPObject)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement, OnGetPluginElement)
     IPC_MESSAGE_HANDLER(PluginHostMsg_ResolveProxy, OnResolveProxy)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRequest, OnHandleURLRequest)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
     IPC_MESSAGE_HANDLER(PluginHostMsg_InitiateHTTPRangeRequest,
                         OnInitiateHTTPRangeRequest)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DeferResourceLoading,
                         OnDeferResourceLoading)
-
+    IPC_MESSAGE_HANDLER(PluginHostMsg_URLRedirectResponse,
+                        OnURLRedirectResponse)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_CheckIfRunInsecureContent,
+                        OnCheckIfRunInsecureContent)
+#if defined(OS_WIN)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessData, OnSetWindowlessData)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_NotifyIMEStatus, OnNotifyIMEStatus)
+#endif
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(PluginHostMsg_FocusChanged,
                         OnFocusChanged);
     IPC_MESSAGE_HANDLER(PluginHostMsg_StartIme,
                         OnStartIme);
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginEnabledRendering,
                         OnAcceleratedPluginEnabledRendering)
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginAllocatedIOSurface,
                         OnAcceleratedPluginAllocatedIOSurface)
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginSwappedIOSurface,
                         OnAcceleratedPluginSwappedIOSurface)
 #endif
-    IPC_MESSAGE_HANDLER(PluginHostMsg_URLRedirectResponse,
-                        OnURLRedirectResponse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 void WebPluginDelegateProxy::OnChannelError() {
   if (plugin_) {
     if (window_) {
       // The actual WebPluginDelegate never got a chance to tell the WebPlugin
@@ skipping 626 matching lines @@
     unsigned long resource_id, int range_request_id) {
   if (!channel_host_.get())
     return NULL;
 
   ResourceClientProxy* proxy =
       new ResourceClientProxy(channel_host_.get(), instance_id_);
   proxy->InitializeForSeekableStream(resource_id, range_request_id);
   return proxy;
 }
 
+void WebPluginDelegateProxy::FetchURL(unsigned long resource_id,
+                                      int notify_id,
+                                      const GURL& url,
+                                      const GURL& first_party_for_cookies,
+                                      const std::string& method,
+                                      const std::string& post_data,
+                                      const GURL& referrer,
+                                      bool notify_redirects,
+                                      bool is_plugin_src_load,
+                                      int origin_pid,
+                                      int render_view_id) {
+  PluginMsg_FetchURL_Params params;
+  params.resource_id = resource_id;
+  params.notify_id = notify_id;
+  params.url = url;
+  params.first_party_for_cookies = first_party_for_cookies;
+  params.method = method;
+  params.post_data = post_data;
+  params.referrer = referrer;
+  params.notify_redirect = notify_redirects;
+  params.is_plugin_src_load = is_plugin_src_load;
+  params.render_view_id = render_view_id;
+  Send(new PluginMsg_FetchURL(instance_id_, params));
+}
+
 #if defined(OS_MACOSX)
 void WebPluginDelegateProxy::OnFocusChanged(bool focused) {
   if (render_view_)
     render_view_->PluginFocusChanged(focused, instance_id_);
 }
 
 void WebPluginDelegateProxy::OnStartIme() {
   if (render_view_)
     render_view_->StartPluginIme();
 }
@@ skipping 65 matching lines @@
 #endif
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
+void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
+                                                         bool* result) {
+  *result = plugin_->CheckIfRunInsecureContent(url);
+}
+
 }  // namespace content