Removes PluginInfoMessageFilter dependency on PluginGroup.

chrome/renderer/chrome_content_renderer_client.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 "chrome/renderer/chrome_content_renderer_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 293 matching lines @@
 
 std::string ChromeContentRendererClient::GetDefaultEncoding() {
   return l10n_util::GetStringUTF8(IDS_DEFAULT_ENCODING);
 }
 
 bool ChromeContentRendererClient::OverrideCreatePlugin(
     content::RenderView* render_view,
     WebFrame* frame,
     const WebPluginParams& params,
     WebPlugin** plugin) {
-  ChromeViewHostMsg_GetPluginInfo_Status status;
-  webkit::WebPluginInfo plugin_info;
-  std::string actual_mime_type;
   std::string orig_mime_type = params.mimeType.utf8();
-
   if (orig_mime_type == content::kBrowserPluginNewMimeType ||
       ((orig_mime_type == content::kBrowserPluginMimeType) &&
         extensions::ExtensionHelper::Get(render_view)->view_type() ==
         VIEW_TYPE_APP_SHELL)) {
       return false;
   }
 
+  ChromeViewHostMsg_GetPluginInfo_Output output;
   render_view->Send(new ChromeViewHostMsg_GetPluginInfo(
       render_view->GetRoutingID(), GURL(params.url),
-      frame->top()->document().url(), orig_mime_type,
-      &status, &plugin_info, &actual_mime_type));
-  *plugin = CreatePlugin(render_view, frame, params,
-                         status, plugin_info, actual_mime_type);
+      frame->top()->document().url(), orig_mime_type, &output));
+  *plugin = CreatePlugin(render_view, frame, params, output);
   return true;
 }
 
 WebPlugin* ChromeContentRendererClient::CreatePluginReplacement(
     content::RenderView* render_view,
     const FilePath& plugin_path) {
   PluginPlaceholder* placeholder =
       PluginPlaceholder::CreateErrorPlugin(render_view, plugin_path);
   return placeholder->plugin();
 }
@@ skipping 20 matching lines @@
   return new prerender::PrerenderWebMediaPlayer(render_view, frame, client,
       delegate, collection, audio_source_provider, audio_renderer_sink,
       message_loop_factory, media_stream_client, media_log);
 #endif
 }
 
 WebPlugin* ChromeContentRendererClient::CreatePlugin(
     content::RenderView* render_view,
     WebFrame* frame,
     const WebPluginParams& original_params,
-    const ChromeViewHostMsg_GetPluginInfo_Status& status,
-    const webkit::WebPluginInfo& plugin,
-    const std::string& actual_mime_type) {
+    const ChromeViewHostMsg_GetPluginInfo_Output& output) {
+  const ChromeViewHostMsg_GetPluginInfo_Status& status = output.status;
+  const webkit::WebPluginInfo& plugin = output.plugin;
+  const std::string& actual_mime_type = output.actual_mime_type;
+  const string16& group_name = output.group_name;
+  const std::string& identifier = output.group_identifier;
   ChromeViewHostMsg_GetPluginInfo_Status::Value status_value = status.value;
   GURL url(original_params.url);
   std::string orig_mime_type = original_params.mimeType.utf8();
   PluginPlaceholder* placeholder = NULL;
 
   // If the browser plugin is to be enabled, this should be handled by the
   // renderer, so the code won't reach here due to the early exit in
   // OverrideCreatePlugin.
   if (status_value == ChromeViewHostMsg_GetPluginInfo_Status::kNotFound ||
       orig_mime_type == content::kBrowserPluginMimeType) {
 #if defined(ENABLE_MOBILE_YOUTUBE_PLUGIN)
     if (PluginPlaceholder::IsYouTubeURL(url, orig_mime_type))
       return PluginPlaceholder::CreateMobileYoutubePlugin(render_view, frame,
           original_params)->plugin();
 #endif
     MissingPluginReporter::GetInstance()->ReportPluginMissing(
         orig_mime_type, url);
     placeholder = PluginPlaceholder::CreateMissingPlugin(
         render_view, frame, original_params);
   } else {
-    scoped_ptr<webkit::npapi::PluginGroup> group(
-        webkit::npapi::PluginList::Singleton()->GetPluginGroup(plugin));
-    string16 name = group->GetGroupName();
-
     // TODO(bauerb): This should be in content/.
     WebPluginParams params(original_params);
     for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
       if (plugin.mime_types[i].mime_type == actual_mime_type) {
         AppendParams(plugin.mime_types[i].additional_param_names,
                      plugin.mime_types[i].additional_param_values,
                      &params.attributeNames,
                      &params.attributeValues);
         break;
       }
@@ skipping 13 matching lines @@
         plugin.name ==
             ASCIIToUTF16(chrome::ChromeContentClient::kNaClPluginName);
     ContentSettingsType content_type =
         is_nacl_plugin ? CONTENT_SETTINGS_TYPE_JAVASCRIPT :
                          CONTENT_SETTINGS_TYPE_PLUGINS;
 
     if ((status_value ==
              ChromeViewHostMsg_GetPluginInfo_Status::kUnauthorized ||
          status_value == ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay ||
          status_value == ChromeViewHostMsg_GetPluginInfo_Status::kBlocked) &&
-        observer->IsPluginTemporarilyAllowed(group->identifier())) {
+        observer->IsPluginTemporarilyAllowed(identifier)) {
       status_value = ChromeViewHostMsg_GetPluginInfo_Status::kAllowed;
     }
 
     // Allow full-page plug-ins for click-to-play.
     if (status_value == ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay &&
         !frame->parent() &&
         !frame->opener() &&
         frame->document().isPluginDocument()) {
       status_value = ChromeViewHostMsg_GetPluginInfo_Status::kAllowed;
     }
@@ skipping 34 matching lines @@
                              is_extension_unrestricted,
                              is_extension_from_webstore,
                              &params)) {
             frame->addMessageToConsole(
                 WebConsoleMessage(
                     WebConsoleMessage::LevelError,
                     "Only unpacked extensions and apps installed from the "
                     "Chrome Web Store can load NaCl modules without enabling "
                     "Native Client in about:flags."));
             placeholder = PluginPlaceholder::CreateBlockedPlugin(
-                render_view, frame, params, plugin, group->identifier(), name,
+                render_view, frame, params, plugin, identifier, group_name,
                 IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_BLOCKED);
             break;
           }
         }
 
         // Delay loading plugins if prerendering.
         // TODO(mmenke):  In the case of prerendering, feed into
         //                ChromeContentRendererClient::CreatePlugin instead, to
         //                reduce the chance of future regressions.
         if (prerender::PrerenderHelper::IsPrerendering(render_view)) {
           placeholder = PluginPlaceholder::CreateBlockedPlugin(
-              render_view, frame, params, plugin, group->identifier(), name,
+              render_view, frame, params, plugin, identifier, group_name,
               IDR_CLICK_TO_PLAY_PLUGIN_HTML, IDS_PLUGIN_LOAD);
           placeholder->set_blocked_for_prerendering(true);
           placeholder->set_allow_loading(true);
           break;
         }
 
         return render_view->CreatePlugin(frame, plugin, params);
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kDisabled: {
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_DISABLED_PLUGIN_HTML, IDS_PLUGIN_DISABLED);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked: {
 #if defined(ENABLE_PLUGIN_INSTALLATION)
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_OUTDATED);
         placeholder->set_allow_loading(true);
         render_view->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
             render_view->GetRoutingID(), placeholder->CreateRoutingId(),
-            group->identifier()));
+            identifier));
 #else
         NOTREACHED();
 #endif
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedDisallowed: {
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_OUTDATED);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kUnauthorized: {
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_NOT_AUTHORIZED);
         placeholder->set_allow_loading(true);
         render_view->Send(new ChromeViewHostMsg_BlockedUnauthorizedPlugin(
             render_view->GetRoutingID(),
-            group->GetGroupName(),
-            group->identifier()));
+            group_name,
+            identifier));
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay: {
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_CLICK_TO_PLAY_PLUGIN_HTML, IDS_PLUGIN_LOAD);
         placeholder->set_allow_loading(true);
         RenderThread::Get()->RecordUserMetrics("Plugin_ClickToPlay");
-        observer->DidBlockContentType(content_type, group->identifier());
+        observer->DidBlockContentType(content_type, identifier);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kBlocked: {
         placeholder = PluginPlaceholder::CreateBlockedPlugin(
-            render_view, frame, params, plugin, group->identifier(), name,
+            render_view, frame, params, plugin, identifier, group_name,
             IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_BLOCKED);
         placeholder->set_allow_loading(true);
         RenderThread::Get()->RecordUserMetrics("Plugin_Blocked");
-        observer->DidBlockContentType(content_type, group->identifier());
+        observer->DidBlockContentType(content_type, identifier);
         break;
       }
     }
   }
   placeholder->SetStatus(status);
   return placeholder->plugin();
 }
 
 // For NaCl content handling plugins, the NaCl manifest is stored in an
 // additonal 'nacl' param associated with the MIME type.
@@ skipping 394 matching lines @@
 bool ChromeContentRendererClient::IsOtherExtensionWithWebRequestInstalled() {
   return extension_dispatcher_->IsOtherExtensionWithWebRequestInstalled();
 }
 
 void ChromeContentRendererClient::RegisterPPAPIInterfaceFactories(
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 }  // namespace chrome