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

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 247 matching lines @@
 
 SkBitmap* ChromeContentRendererClient::GetSadPluginBitmap() {
   return ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_SAD_PLUGIN);
 }
 
 std::string ChromeContentRendererClient::GetDefaultEncoding() {
   return l10n_util::GetStringUTF8(IDS_DEFAULT_ENCODING);
 }
 
 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::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);
+
+  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.
+  }
 
-  bool found = render_view->GetPluginInfo(
-      url, frame->top()->document().url(), orig_mime_type, &info,
-      &actual_mime_type);
-
-  if (!found)
-    return NULL;
-
-  *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,
                               PLUGIN_TYPE_MISMATCH_NONE,
                               PLUGIN_TYPE_MISMATCH_NUM_EVENTS);
   } else if (orig_mime_type.empty()) {
     UMA_HISTOGRAM_ENUMERATION(kPluginTypeMismatch,
                               PLUGIN_TYPE_MISMATCH_ORIG_EMPTY,
                               PLUGIN_TYPE_MISMATCH_NUM_EVENTS);
   } else if (orig_mime_type == kApplicationOctetStream) {
@@ skipping 46 matching lines @@
 
   if (group->IsVulnerable(info)) {
     if (outdated_policy == CONTENT_SETTING_ASK ||
         outdated_policy == CONTENT_SETTING_BLOCK) {
       if (outdated_policy == CONTENT_SETTING_ASK) {
         render_view->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
             render_view->routing_id(), group->GetGroupName(),
             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);
     }
   }
 
   ContentSettingsObserver* observer = ContentSettingsObserver::Get(render_view);
   ContentSetting host_setting =
       observer->GetContentSetting(CONTENT_SETTINGS_TYPE_PLUGINS);
 
   if (group->RequiresAuthorization(info) &&
       authorize_policy == CONTENT_SETTING_ASK &&
       (plugin_setting == CONTENT_SETTING_ALLOW ||
        plugin_setting == CONTENT_SETTING_ASK) &&
       host_setting == CONTENT_SETTING_DEFAULT) {
     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);
   }
 
   // Treat Native Client invocations like Javascript.
   bool is_nacl_plugin =
       info.name == ASCIIToUTF16(ChromeContentClient::kNaClPluginName);
   if (is_nacl_plugin) {
     plugin_setting =
         observer->GetContentSetting(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
   }
 
   if (plugin_setting == CONTENT_SETTING_ALLOW ||
       host_setting == CONTENT_SETTING_ALLOW ||
       info.path.value() == webkit::npapi::kDefaultPluginLibraryName) {
     // 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.
     if (is_nacl_plugin) {
       bool allow_nacl = cmd->HasSwitch(switches::kEnableNaCl);
       if (!allow_nacl) {
         const char* kNaClPluginMimeType = "application/x-nacl";
         const char* kNaClPluginManifestAttribute = "nacl";
 
         GURL nexe_url;
@@ skipping 27 matching lines @@
         allow_nacl = extension &&
             (extension->from_webstore() ||
             extension->location() == Extension::COMPONENT ||
             extension->location() == Extension::LOAD);
       }
 
       if (!allow_nacl) {
         // 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);
       }
     }
 
     bool pepper_plugin_was_registered = false;
     scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
         render_view->pepper_delegate()->CreatePepperPluginModule(
             info, &pepper_plugin_was_registered));
     if (pepper_plugin_was_registered) {
       if (pepper_module) {
         return render_view->CreatePepperPlugin(
             frame, params, info.path, pepper_module.get());
       }
       return NULL;
     }
 
     return render_view->CreateNPAPIPlugin(
         frame, params, info.path, actual_mime_type);
   }
 
   observer->DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, resource);
   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);
   }
 }
 
 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();
 }
 
 void ChromeContentRendererClient::ShowErrorPage(RenderView* render_view,
                                                 WebKit::WebFrame* frame,
                                                 int http_status_code) {
   // Use an internal error page, if we have one for the status code.
   if (LocalizedError::HasStrings(LocalizedError::kHttpErrorDomain,
@@ skipping 248 matching lines @@
   if (spellcheck_.get())
     thread->RemoveObserver(spellcheck_.get());
   SpellCheck* new_spellcheck = new SpellCheck();
   if (spellcheck_provider_)
     spellcheck_provider_->SetSpellCheck(new_spellcheck);
   spellcheck_.reset(new_spellcheck);
   thread->AddObserver(new_spellcheck);
 }
 
 }  // namespace chrome