Move more of the plugin code in the renderer to use RenderFrame instead of RenderView.

content/browser/plugin_service_impl.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_service_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 349 matching lines @@
 
   // TODO(ddorwin): Uncomment once out of process is supported.
   // DCHECK(info->is_out_of_process);
 
   // This broker isn't loaded by any broker process, so create a new process.
   return PpapiPluginProcessHost::CreateBrokerHost(*info);
 }
 
 void PluginServiceImpl::OpenChannelToNpapiPlugin(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.insert(client);
 
   // Make sure plugins are loaded if necessary.
   PluginServiceFilterParams params = {
     render_process_id,
-    render_view_id,
+    render_frame_id,
     page_url,
     client->GetResourceContext()
   };
   GetPlugins(base::Bind(
       &PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin,
       base::Unretained(this), params, url, mime_type, client));
 }
 
 void PluginServiceImpl::OpenChannelToPpapiPlugin(
     int render_process_id,
@@ skipping 30 matching lines @@
   DCHECK(ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.erase(client);
 }
 
 void PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin(
     const PluginServiceFilterParams& params,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     const std::vector<WebPluginInfo>&) {
-  GetAllowedPluginForOpenChannelToPlugin(params.render_process_id,
-      params.render_view_id, url, params.page_url, mime_type, client,
-      params.resource_context);
+  GetAllowedPluginForOpenChannelToPlugin(
+      params.render_process_id, params.render_frame_id, url, params.page_url,
+      mime_type, client, params.resource_context);
 }
 
 void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     ResourceContext* resource_context) {
   WebPluginInfo info;
   bool allow_wildcard = true;
   bool found = GetPluginInfo(
-      render_process_id, render_view_id, resource_context,
+      render_process_id, render_frame_id, resource_context,
       url, page_url, mime_type, allow_wildcard,
       NULL, &info, NULL);
   base::FilePath plugin_path;
   if (found)
     plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PluginServiceImpl::FinishOpenChannelToPlugin,
@@ skipping 31 matching lines @@
     std::vector<WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   bool use_stale = false;
   PluginList::Singleton()->GetPluginInfoArray(
       url, mime_type, allow_wildcard, &use_stale, NPAPIPluginsSupported(),
       plugins, actual_mime_types);
   return use_stale;
 }
 
 bool PluginServiceImpl::GetPluginInfo(int render_process_id,
-                                      int render_view_id,
+                                      int render_frame_id,
                                       ResourceContext* context,
                                       const GURL& url,
                                       const GURL& page_url,
                                       const std::string& mime_type,
                                       bool allow_wildcard,
                                       bool* is_stale,
                                       WebPluginInfo* info,
                                       std::string* actual_mime_type) {
   std::vector<WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
   bool stale = GetPluginInfoArray(
       url, mime_type, allow_wildcard, &plugins, &mime_types);
   if (is_stale)
     *is_stale = stale;
 
   for (size_t i = 0; i < plugins.size(); ++i) {
     if (!filter_ || filter_->IsPluginAvailable(render_process_id,
-                                               render_view_id,
+                                               render_frame_id,
                                                context,
                                                url,
                                                page_url,
                                                &plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
@@ skipping 289 matching lines @@
           window, kPluginVersionAtomProperty, plugin_version);
   return true;
 }
 
 bool PluginServiceImpl::IsPluginWindow(HWND window) {
   return gfx::GetClassName(window) == base::string16(kNativeWindowClassName);
 }
 #endif
 
 }  // namespace content