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

content/browser/plugin_service.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/browser/plugin_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 44 matching lines @@
 // A callback for GetPlugins() that then gets the freshly loaded plugin groups
 // and runs the callback for GetPluginGroups().
 static void GetPluginsForGroupsCallback(
     const PluginService::GetPluginGroupsCallback& callback,
     const std::vector<webkit::WebPluginInfo>& plugins) {
   std::vector<webkit::npapi::PluginGroup> groups;
   webkit::npapi::PluginList::Singleton()->GetPluginGroups(false, &groups);
   callback.Run(groups);
 }
 
+static void GetPluginsAndIgnoreCallback(
+    const base::Closure& callback,
+    const std::vector<webkit::WebPluginInfo>& plugins) {
+  callback.Run();
+}
+
 // Callback set on the PluginList to assert that plugin loading happens on the
 // correct thread.
 void WillLoadPluginsCallback() {
   // TODO(rsesek): Change these to CHECKs.
 #if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_MACOSX))
   LOG_IF(ERROR, !BrowserThread::CurrentlyOn(BrowserThread::FILE));
 #else
   LOG(ERROR) << "Plugin loading should happen out-of-process.";
 #endif
 }
@@ skipping 400 matching lines @@
 
   PluginProcessHost* plugin_host = FindOrStartNpapiPluginProcess(plugin_path);
   if (plugin_host) {
     client->OnFoundPluginProcessHost(plugin_host);
     plugin_host->OpenChannelToPlugin(client);
   } else {
     client->OnError();
   }
 }
 
+bool PluginService::GetPluginInfoArray(
+    const GURL& url,
+    const std::string& mime_type,
+    bool allow_wildcard,
+    std::vector<webkit::WebPluginInfo>* plugins,
+    std::vector<std::string>* actual_mime_types) {
+  bool use_stale = false;
+  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
+      url, mime_type, allow_wildcard, &use_stale, plugins, actual_mime_types);
+  return use_stale;
+}
+
 bool PluginService::GetPluginInfo(int render_process_id,
                                   int render_view_id,
                                   const content::ResourceContext& context,
                                   const GURL& url,
                                   const GURL& page_url,
                                   const std::string& mime_type,
                                   bool allow_wildcard,
                                   bool* use_stale,
                                   webkit::WebPluginInfo* info,
                                   std::string* actual_mime_type) {
@@ skipping 66 matching lines @@
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<webkit::WebPluginInfo> plugins;
   webkit::npapi::PluginList::Singleton()->GetPlugins(&plugins);
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(&RunGetPluginsCallback, callback, plugins));
 }
 
+void PluginService::EnsurePluginsLoaded(const base::Closure& callback) {
+  GetPlugins(base::Bind(&GetPluginsAndIgnoreCallback, callback));
+}
+
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
   webkit::npapi::PluginList::Singleton()->RefreshPlugins();
@@ skipping 64 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif