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

content/browser/plugin_process_host.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/browser/plugin_process_host.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <utility>  // for pair<>
 #endif
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/browser_child_process_host_impl.h"
+#include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/plugin_process_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
+#include "content/public/browser/resource_context.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_switches.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(USE_X11)
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
@@ skipping 199 matching lines @@
       env,
 #endif
       cmd_line);
 
   // The plugin needs to be shutdown gracefully, i.e. NP_Shutdown needs to be
   // called on the plugin. The plugin process exits when it receives the
   // OnChannelError notification indicating that the browser plugin channel has
   // been destroyed.
   process_->SetTerminateChildOnShutdown(false);
 
+  ResourceMessageFilter::GetContextsCallback get_contexts_callback(
+      base::Bind(&PluginProcessHost::GetContexts,
+      base::Unretained(this)));
+
+  // TODO(jam): right now we're passing NULL for appcache, blob storage, and
+  // file system. If NPAPI plugins actually use this, we'll have to plumb them.
+  ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
+      process_->GetData().id, PROCESS_TYPE_PLUGIN, NULL, NULL, NULL,
+      get_contexts_callback);
+  process_->GetHost()->AddFilter(resource_message_filter);
   return true;
 }
 
 void PluginProcessHost::ForceShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   Send(new PluginProcessMsg_NotifyRenderersOfPendingShutdown());
   process_->ForceShutdown();
 }
 
 void PluginProcessHost::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
   process_->GetHost()->AddFilter(filter);
 }
 
 bool PluginProcessHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PluginProcessHost, msg)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_ChannelCreated, OnChannelCreated)
+    IPC_MESSAGE_HANDLER(PluginProcessHostMsg_ChannelDestroyed,
+                        OnChannelDestroyed)
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginWindowDestroyed,
                         OnPluginWindowDestroyed)
 #endif
 #if defined(TOOLKIT_GTK)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_MapNativeViewId,
                         OnMapNativeViewId)
 #endif
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginSelectWindow,
                         OnPluginSelectWindow)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginShowWindow,
                         OnPluginShowWindow)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginHideWindow,
                         OnPluginHideWindow)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginSetCursorVisibility,
                         OnPluginSetCursorVisibility)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
-  DCHECK(handled);
   return handled;
 }
 
 void PluginProcessHost::OnChannelConnected(int32 peer_pid) {
   for (size_t i = 0; i < pending_requests_.size(); ++i) {
     RequestPluginChannel(pending_requests_[i]);
   }
 
   pending_requests_.clear();
 }
@@ skipping 16 matching lines @@
   pending_requests_.clear();
 
   while (!sent_requests_.empty()) {
     Client* client = sent_requests_.front();
     if (client)
       client->OnError();
     sent_requests_.pop_front();
   }
 }
 
-// static
-void PluginProcessHost::CancelPendingRequestsForResourceContext(
-    ResourceContext* context) {
-  for (PluginProcessHostIterator host_it; !host_it.Done(); ++host_it) {
-    PluginProcessHost* host = *host_it;
-    for (size_t i = 0; i < host->pending_requests_.size(); ++i) {
-      if (host->pending_requests_[i]->GetResourceContext() == context) {
-        host->pending_requests_[i]->OnError();
-        host->pending_requests_.erase(host->pending_requests_.begin() + i);
-        --i;
-      }
-    }
-  }
-}
-
 void PluginProcessHost::OpenChannelToPlugin(Client* client) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowserChildProcessHostImpl::NotifyProcessInstanceCreated,
                  process_->GetData()));
   client->SetPluginInfo(info_);
   if (process_->GetHost()->IsChannelOpening()) {
     // The channel is already in the process of being opened.  Put
     // this "open channel" request into a queue of requests that will
     // be run once the channel is open.
@@ skipping 45 matching lines @@
     client->OnSentPluginChannelRequest();
   } else {
     client->OnError();
   }
 }
 
 void PluginProcessHost::OnChannelCreated(
     const IPC::ChannelHandle& channel_handle) {
   Client* client = sent_requests_.front();
 
-  if (client)
+  if (client) {
+    resource_context_map_[client->ID()] = client->GetResourceContext();
     client->OnChannelOpened(channel_handle);
+  }
   sent_requests_.pop_front();
 }
 
+void PluginProcessHost::OnChannelDestroyed(int renderer_id) {
+  resource_context_map_.erase(renderer_id);
+}
+
+void PluginProcessHost::GetContexts(const ResourceHostMsg_Request& request,
+                                    ResourceContext** resource_context,
+                                    net::URLRequestContext** request_context) {
+  *resource_context = resource_context_map_[request.origin_pid];
+  *request_context = (*resource_context)->GetRequestContext();
+}
+
 }  // namespace content