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

content/renderer/render_view.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 "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 565 matching lines @@
   if (load_progress_tracker_ == NULL)
     load_progress_tracker_.reset(new LoadProgressTracker(this));
 }
 
 void RenderView::PluginCrashed(const FilePath& plugin_path) {
   Send(new ViewHostMsg_CrashedPlugin(routing_id_, plugin_path));
 }
 
 WebPlugin* RenderView::CreatePluginNoCheck(WebFrame* frame,
                                            const WebPluginParams& params) {
-  webkit::WebPluginInfo info;
-  std::string mime_type;
-  bool found = GetPluginInfo(params.url, frame->top()->document().url(),
-                             params.mimeType.utf8(), &info, &mime_type);
-  if (!found)
-    return NULL;
-
-  bool pepper_plugin_was_registered = false;
-  scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
-      pepper_delegate_.CreatePepperPluginModule(info,
-                                                &pepper_plugin_was_registered));
-  if (pepper_plugin_was_registered) {
-    if (pepper_module)
-      return CreatePepperPlugin(frame, params, info.path, pepper_module.get());
-    return NULL;
+  std::vector<webkit::WebPluginInfo> plugins;
+  std::vector<std::string> mime_types;
+  std::vector<bool> allowed;
+  GetMatchingPlugins(
+      params.url, frame->top()->document().url(),
+      params.mimeType.utf8(), &plugins, &mime_types, &allowed);
+  for (size_t i = 0; i < plugins.size(); ++i) {
+    if (allowed[i]) {
+      bool pepper_plugin_was_registered = false;
+      scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
+          pepper_delegate_.CreatePepperPluginModule(
+              plugins[i], &pepper_plugin_was_registered));
+      if (pepper_plugin_was_registered) {
+        if (pepper_module)
+          return CreatePepperPlugin(frame, params, plugins[i].path,
+                                    pepper_module.get());
+        return NULL;
+      }
+      return CreateNPAPIPlugin(frame, params, plugins[i].path, mime_types[i]);
+    }
   }
-  return CreateNPAPIPlugin(frame, params, info.path, mime_type);
+  NOTREACHED() << "No allowed plug-in found";
+  return NULL;
 }
 
 void RenderView::RegisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.insert(delegate);
   // If the renderer is visible, set initial visibility and focus state.
   if (!is_hidden()) {
 #if defined(OS_MACOSX)
     delegate->SetContainerVisibility(true);
     if (webview() && webview()->isActive())
       delegate->SetWindowFocus(true);
 #endif
   }
   // Plugins start assuming the content has focus (so that they work in
   // environments where RenderView isn't hosting them), so we always have to
   // set the initial state. See webplugin_delegate_impl.h for details.
   delegate->SetContentAreaFocus(has_focus());
 }
 
 void RenderView::UnregisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.erase(delegate);
 }
 
-bool RenderView::GetPluginInfo(const GURL& url,
-                               const GURL& page_url,
-                               const std::string& mime_type,
-                               webkit::WebPluginInfo* plugin_info,
-                               std::string* actual_mime_type) {
-  bool found = false;
-  Send(new ViewHostMsg_GetPluginInfo(
-      routing_id_, url, page_url, mime_type, &found, plugin_info,
-      actual_mime_type));
-  return found;
+void RenderView::GetMatchingPlugins(
+    const GURL& url,
+    const GURL& page_url,
+    const std::string& mime_type,
+    std::vector<webkit::WebPluginInfo>* plugins,
+    std::vector<std::string>* mime_types,
+    std::vector<bool>* allowed) {
+  Send(new ViewHostMsg_GetMatchingPlugins(
+      routing_id_, url, page_url, mime_type, plugins, mime_types, allowed));
 }
 
 base::SharedMemoryHandle RenderView::HostAllocateSharedMemoryBuffer(
     uint32 buffer_size) {
   base::SharedMemoryHandle mem_handle;
   Send(new ViewHostMsg_AllocateSharedMemoryBuffer(buffer_size, &mem_handle));
   return mem_handle;
 }
 
 bool RenderView::OnMessageReceived(const IPC::Message& message) {
@@ skipping 3993 matching lines @@
 }
 
 void RenderView::OnLockMouseACK(bool succeeded) {
   pepper_delegate_.OnLockMouseACK(succeeded);
 }
 
 void RenderView::OnMouseLockLost() {
   pepper_delegate_.OnMouseLockLost();
 }