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

content/browser/plugin_service.h

 // 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.
 
 // This class responds to requests from renderers for the list of plugins, and
 // also a proxy object for plugin instances.
 
 #ifndef CONTENT_BROWSER_PLUGIN_SERVICE_H_
 #define CONTENT_BROWSER_PLUGIN_SERVICE_H_
 #pragma once
@@ skipping 103 matching lines @@
                                 PluginProcessHost::Client* client);
   void OpenChannelToPpapiPlugin(const FilePath& path,
                                 PpapiPluginProcessHost::Client* client);
   void OpenChannelToPpapiBroker(const FilePath& path,
                                 PpapiBrokerProcessHost::Client* client);
 
   // Cancels opening a channel to a NPAPI plugin.
   void CancelOpenChannelToNpapiPlugin(PluginProcessHost::Client* client);
 
   // Gets the plugin in the list of plugins that matches the given url and mime
-  // type. Must be called on the FILE thread if |use_stale| is NULL.
+  // type. Returns true if the data is frome a stale plugin list, false if it
+  // is up to date. This can be called from any thread.
+  bool GetPluginInfoArray(const GURL& url,

[jam, 2011/09/30 17:01:21]

is it really necessary to add a wrapper function around PluginList instead of
having callers call it directly?

[Bernhard Bauer, 2011/09/30 17:22:21]

That's at least Robert's plan for the future. I copied this method from
http://codereview.chromium.org/8071013/.

[jam, 2011/09/30 17:40:19]

I see. it's a bit unfortunate to have these wrappers, but ok.

+                          const std::string& mime_type,
+                          bool allow_wildcard,
+                          std::vector<webkit::WebPluginInfo>* info,
+                          std::vector<std::string>* actual_mime_types);
+
+  // Gets plugin info for an individual plugin and filters the plugins using
+  // the |context| and renderer IDs. This will report whether the data is stale
+  // via |is_stale| and returns whether or not the plugin can be found.
   bool 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);
 
   // Marks the plugin list as dirty and will cause the plugins to be reloaded
   // on the next access through GetPlugins() or GetPluginGroups().
   void RefreshPluginList();
 
   // Asynchronously loads plugins if necessary and then calls back to the
-  // provided function on the calling MessageLoop on completion.
+  // provided function on the calling MessageLoop with the list of plugins
+  // on completion.
   void GetPlugins(const GetPluginsCallback& callback);
 
   // Asynchronously loads the list of plugin groups if necessary and then calls
   // back to the provided function on the calling MessageLoop on completion.
   void GetPluginGroups(const GetPluginGroupsCallback& callback);
 
+  // Asynchronously loads plugins if necessary and then calls back to the
+  // provided function on the calling MessageLoop on completion.
+  void EnsurePluginsLoaded(const base::Closure& callback);

[jam, 2011/09/30 17:01:21]

this function doesn't seem necessary since it can already be done with existing
methods (the fewer methods there are, the better!). if someone just wants to
know that plugins are loaded, they can call GetPlugins and ignore the result.

[Bernhard Bauer, 2011/09/30 17:22:21]

I find it a bit awkward having the list of plug-ins as an additional parameter
and then ignoring it. ChromeRenderMessageFilter::GetPluginInfo already has
enough parameters as it is (and I was actually hitting the base::Callback limits
with it!).

[jam, 2011/09/30 17:40:19]

we already do this (i.e. BufferedRersourceHandler)
we ignore parameters all the time in various methods, so that's nothing new.

For a base class like PluginService that's used by a lot of code, having the
fewest number of methods is useful, because it makes it easy for developers not
familiar with it to quickly scan all the public methods. in this case, i think
the cost of having a CRMF method take an unused parameter is low vs adding
another function to PS

[Bernhard Bauer, 2011/10/05 13:34:33]

ok, done.

+
   // Tells all the renderer processes to throw away their cache of the plugin
   // list, and optionally also reload all the pages with plugins.
   // NOTE: can only be called on the UI thread.
   static void PurgePluginListCache(bool reload_pages);
 
   void set_filter(content::PluginServiceFilter* filter) {
     filter_ = filter;
   }
   content::PluginServiceFilter* filter() { return filter_; }
 
@@ skipping 70 matching lines @@
   content::PluginServiceFilter* filter_;
 
   std::set<PluginProcessHost::Client*> pending_plugin_clients_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginService);
 };
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(PluginService);
 
 #endif  // CONTENT_BROWSER_PLUGIN_SERVICE_H_