Use a placeholder instead of the default plugin for missing plug-ins on Mac and Linux.

chrome/renderer/chrome_content_renderer_client.cc

Index: chrome/renderer/chrome_content_renderer_client.cc
diff --git a/chrome/renderer/chrome_content_renderer_client.cc b/chrome/renderer/chrome_content_renderer_client.cc
index 1e97675850ea5241a799911b6efde067d743631a..545d5749039d364e8dd98276405d436c517e2bed 100644
--- a/chrome/renderer/chrome_content_renderer_client.cc
+++ b/chrome/renderer/chrome_content_renderer_client.cc
@@ -265,39 +265,55 @@ std::string ChromeContentRendererClient::GetDefaultEncoding() {
 }
 
 bool ChromeContentRendererClient::OverrideCreatePlugin(
-      RenderView* render_view,
-      WebFrame* frame,
-      const WebPluginParams& params,
-      WebKit::WebPlugin** plugin) {
-  bool is_default_plugin;
-  *plugin = CreatePlugin(render_view, frame, params, &is_default_plugin);
-  if (!*plugin || is_default_plugin)
-    MissingPluginReporter::GetInstance()->ReportPluginMissing(
-        params.mimeType.utf8(), params.url);
+    RenderView* render_view,
+    WebFrame* frame,
+    const WebPluginParams& params,
+    WebKit::WebPlugin** plugin) {
+  *plugin = CreatePlugin(render_view, frame, params);
   return true;
 }
 
 WebPlugin* ChromeContentRendererClient::CreatePlugin(
-      RenderView* render_view,
-      WebFrame* frame,
-      const WebPluginParams& original_params,
-      bool* is_default_plugin) {
-  *is_default_plugin = false;
+    RenderView* render_view,
+    WebFrame* frame,
+    const WebPluginParams& original_params) {
   CommandLine* cmd = CommandLine::ForCurrentProcess();
-  webkit::WebPluginInfo info;
   GURL url(original_params.url);
   std::string orig_mime_type = original_params.mimeType.utf8();
-  std::string actual_mime_type;
-
-  bool found = render_view->GetPluginInfo(
-      url, frame->top()->document().url(), orig_mime_type, &info,
-      &actual_mime_type);
+  std::vector<webkit::WebPluginInfo> plugins;
+  std::vector<std::string> mime_types;
+  std::vector<bool> allowed;
+  render_view->GetMatchingPlugins(
+      url, frame->top()->document().url(), orig_mime_type,
+      &plugins, &mime_types, &allowed);
 
-  if (!found)
-    return NULL;
+  webkit::WebPluginInfo info;
+  std::string actual_mime_type;
+  if (plugins.empty()) {
+    MissingPluginReporter::GetInstance()->ReportPluginMissing(
+        orig_mime_type, url);
+    return CreatePluginPlaceholder(
+        render_view, frame, original_params, NULL, IDR_BLOCKED_PLUGIN_HTML,
+        IDS_PLUGIN_NOT_FOUND, false, false);
+  } else {
+    bool plugin_allowed = false;
+    for (size_t i = 0; i < plugins.size(); ++i) {
+      plugin_allowed = allowed[i];
+      if (i == 0 || plugin_allowed) {

[jam, 2011/09/27 16:51:34]

it's not clear to me why you do this, i.e. why the renderer now needs to get a
list of plugins and pick one itself. why can't this be done in the browser?

[Bernhard Bauer, 2011/09/27 21:21:39]

I want to differentiate between the case where there is no plug-in installed for
a given MIME type (in which case we show the missing plug-in placeholder), or
there is at least one plug-in, but none of them is enabled (in which case we may
want to show a different placeholder, with information about the first one of
those plug-ins). The browser side of this is in content/ though, and I'd prefer
to have this logic in chrome/.

[jam, 2011/09/29 01:03:32]

Since content's renderer side doesn't care about getting multiple plugins: why
not have a separate IPC that's used in chrome to get a list. That IPC can be
dispatched in ChromeRenderMessageFilter, and it can do the filtering and return
a boolean indicating whether there's no plugin or there's no enabled plugin.
Then we can get rid of the filtering concept from content?

[Bernhard Bauer, 2011/09/29 13:20:47]

Ok, that sounds good. Then we can also do additional checks (is the plug-in
out-of-date? Is it blocked? etc.) there. 
I don't think that's going to be possible though. There are still more calls to
get a plug-in for a MIME type from content/ (the actual OpenChannelToPlugin
call, as well as RenderView::CreatePluginNoCheck, which is called when loading a
blocked plug-in), and we need to make sure those obey the same rules for
disabled plug-ins.

[jam, 2011/09/29 16:31:10]

yep sounds good.
ah right, nm :)

+        info = plugins[i];
+        actual_mime_type = mime_types[i];
+      }
+      if (plugin_allowed)
+        break;
+    }
+    if (!plugin_allowed)
+      return NULL;  // TODO(bauerb): Show placeholder for disabled plug-in.
+  }
 
-  *is_default_plugin =
-    info.path.value() == webkit::npapi::kDefaultPluginLibraryName;
+  if (info.path.value() == webkit::npapi::kDefaultPluginLibraryName) {
+    MissingPluginReporter::GetInstance()->ReportPluginMissing(
+        orig_mime_type, url);
+  }
 
   if (orig_mime_type == actual_mime_type) {
     UMA_HISTOGRAM_ENUMERATION(kPluginTypeMismatch,
@@ -364,7 +380,7 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
             GURL(group->GetUpdateURL())));
       }
       return CreatePluginPlaceholder(
-          render_view, frame, params, *group, IDR_BLOCKED_PLUGIN_HTML,
+          render_view, frame, params, group.get(), IDR_BLOCKED_PLUGIN_HTML,
           IDS_PLUGIN_OUTDATED, false, outdated_policy == CONTENT_SETTING_ASK);
     } else {
       DCHECK(outdated_policy == CONTENT_SETTING_ALLOW);
@@ -383,7 +399,7 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
     render_view->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
         render_view->routing_id(), group->GetGroupName(), GURL()));
     return CreatePluginPlaceholder(
-        render_view, frame, params, *group, IDR_BLOCKED_PLUGIN_HTML,
+        render_view, frame, params, group.get(), IDR_BLOCKED_PLUGIN_HTML,
         IDS_PLUGIN_NOT_AUTHORIZED, false, true);
   }
 
@@ -401,8 +417,8 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
     // Delay loading plugins if prerendering.
     if (prerender::PrerenderHelper::IsPrerendering(render_view)) {
       return CreatePluginPlaceholder(
-          render_view, frame, params, *group, IDR_CLICK_TO_PLAY_PLUGIN_HTML,
-          IDS_PLUGIN_LOAD, true, true);
+          render_view, frame, params, group.get(),
+          IDR_CLICK_TO_PLAY_PLUGIN_HTML, IDS_PLUGIN_LOAD, true, true);
     }
 
     // Enforce the Chrome WebStore restriction on the Native Client plugin.
@@ -450,7 +466,7 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
         // TODO(bbudge) Webkit will crash if this is a full-frame plug-in and
         // we return NULL. Prepare a patch to fix that, and return NULL here.
         return CreatePluginPlaceholder(
-            render_view, frame, params, *group, IDR_BLOCKED_PLUGIN_HTML,
+            render_view, frame, params, group.get(), IDR_BLOCKED_PLUGIN_HTML,
             IDS_PLUGIN_BLOCKED, false, false);
       }
     }
@@ -475,12 +491,12 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
   if (plugin_setting == CONTENT_SETTING_ASK) {
     RenderThread::RecordUserMetrics("Plugin_ClickToPlay");
     return CreatePluginPlaceholder(
-        render_view, frame, params, *group, IDR_CLICK_TO_PLAY_PLUGIN_HTML,
+        render_view, frame, params, group.get(), IDR_CLICK_TO_PLAY_PLUGIN_HTML,
         IDS_PLUGIN_LOAD, false, true);
   } else {
     RenderThread::RecordUserMetrics("Plugin_Blocked");
     return CreatePluginPlaceholder(
-        render_view, frame, params, *group, IDR_BLOCKED_PLUGIN_HTML,
+        render_view, frame, params, group.get(), IDR_BLOCKED_PLUGIN_HTML,
         IDS_PLUGIN_BLOCKED, false, true);
   }
 }
@@ -489,22 +505,30 @@ WebPlugin* ChromeContentRendererClient::CreatePluginPlaceholder(
     RenderView* render_view,
     WebFrame* frame,
     const WebPluginParams& params,
-    const webkit::npapi::PluginGroup& group,
+    const webkit::npapi::PluginGroup* group,
     int resource_id,
     int message_id,
     bool is_blocked_for_prerendering,
     bool allow_loading) {
   // |blocked_plugin| will delete itself when the WebViewPlugin
   // is destroyed.
+  string16 name;
+  string16 message;
+  if (group) {
+    name = group->GetGroupName();
+    message = l10n_util::GetStringFUTF16(message_id, name);
+  } else {
+    message = l10n_util::GetStringUTF16(message_id);
+  }
+
   BlockedPlugin* blocked_plugin =
       new BlockedPlugin(render_view,
                         frame,
-                        group,
                         params,
                         render_view->webkit_preferences(),
                         resource_id,
-                        l10n_util::GetStringFUTF16(message_id,
-                                                   group.GetGroupName()),
+                        name,
+                        message,
                         is_blocked_for_prerendering,
                         allow_loading);
   return blocked_plugin->plugin();