Ensure we don't load plugins on the IO thread

webkit/glue/plugins/plugin_list.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef WEBKIT_GLUE_PLUGIN_PLUGIN_LIST_H__
 #define WEBKIT_GLUE_PLUGIN_PLUGIN_LIST_H__
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
+#include "base/lock.h"
 #include "webkit/glue/webplugininfo.h"
 #include "webkit/glue/plugins/nphostapi.h"
 
 class GURL;
 
 namespace base {
 
 template <typename T>
 struct DefaultLazyInstanceTraits;
 
@@ skipping 35 matching lines @@
   PluginEntryPoints entry_points;
 };
 
 // The PluginList is responsible for loading our NPAPI based plugins. It does
 // so in whatever manner is appropriate for the platform. On Windows, it loads
 // plugins from a known directory by looking for DLLs which start with "NP",
 // and checking to see if they are valid NPAPI libraries. On the Mac, it walks
 // the machine-wide and user plugin directories and loads anything that has
 // the correct types. On Linux, it walks the plugin directories as well
 // (e.g. /usr/lib/browser-plugins/).
+// This object is thread safe.
 class PluginList {
  public:
-  // Gets the one instance of the PluginList.  Accessing the singleton causes
-  // the PluginList to look on disk for existing plugins.  It does not actually
-  // load libraries, that will only happen when you initialize the plugin for
-  // the first time.
+  // Gets the one instance of the PluginList.
   static PluginList* Singleton();
 
+  // Returns true iff the plugin list has been loaded already.
+  bool PluginsLoaded();
+
   // Clear the plugins_loaded_ bit to force a refresh next time we retrieve
   // plugins.
-  static void ResetPluginsLoaded();
+  void ResetPluginsLoaded();
 
-  // Add an extra plugin to load when we actually do the loading.  This is
-  // static because we want to be able to add to it without searching the disk
-  // for plugins.  Must be called before the plugins have been loaded.
-  static void AddExtraPluginPath(const FilePath& plugin_path);
+  // Add an extra plugin to load when we actually do the loading.  Must be
+  // called before the plugins have been loaded.
+  void AddExtraPluginPath(const FilePath& plugin_path);
 
   // Same as above, but specifies a directory in which to search for plugins.
-  static void AddExtraPluginDir(const FilePath& plugin_dir);
+  void AddExtraPluginDir(const FilePath& plugin_dir);
 
   // Register an internal plugin with the specified plugin information and
   // function pointers.  An internal plugin must be registered before it can
   // be loaded using PluginList::LoadPlugin().
-  static void RegisterInternalPlugin(const PluginVersionInfo& info);
+  void RegisterInternalPlugin(const PluginVersionInfo& info);
 
   // Creates a WebPluginInfo structure given a plugin's path.  On success
   // returns true, with the information being put into "info".  If it's an
   // internal plugin, "entry_points" is filled in as well with a
   // internally-owned PluginEntryPoints pointer.
   // Returns false if the library couldn't be found, or if it's not a plugin.
-  static bool ReadPluginInfo(const FilePath& filename,
-                             WebPluginInfo* info,
-                             const PluginEntryPoints** entry_points);
+  bool ReadPluginInfo(const FilePath& filename,
+                      WebPluginInfo* info,
+                      const PluginEntryPoints** entry_points);
 
   // Populate a WebPluginInfo from a PluginVersionInfo.
   static bool CreateWebPluginInfo(const PluginVersionInfo& pvi,
                                   WebPluginInfo* info);
 
   // Shutdown all plugins.  Should be called at process teardown.
   void Shutdown();
 
   // Get all the plugins
-  bool GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins);
+  void GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins);
 
   // Returns true if a plugin is found for the given url and mime type.
   // The mime type which corresponds to the URL is optionally returned
   // back.
   // The allow_wildcard parameter controls whether this function returns
   // plugins which support wildcard mime types (* as the mime type).
   bool GetPluginInfo(const GURL& url,
                      const std::string& mime_type,
                      const std::string& clsid,
                      bool allow_wildcard,
                      WebPluginInfo* info,
                      std::string* actual_mime_type);
 
   // Get plugin info by plugin path. Returns true if the plugin is found and
   // WebPluginInfo has been filled in |info|.
   bool GetPluginInfoByPath(const FilePath& plugin_path,
                            WebPluginInfo* info);
 
   // Load a specific plugin with full path.
-  void LoadPlugin(const FilePath& filename);
+  void LoadPlugin(const FilePath& filename,
+                  std::vector<WebPluginInfo>* plugins);
 
  private:
   // Constructors are private for singletons
   PluginList();
 
   // Load all plugins from the default plugins directory
   void LoadPlugins(bool refresh);
 
   // Load all plugins from a specific directory
-  void LoadPluginsFromDir(const FilePath& path);
+  void LoadPluginsFromDir(const FilePath& path,
+                          std::vector<WebPluginInfo>* plugins);
 
   // Returns true if we should load the given plugin, or false otherwise.
-  bool ShouldLoadPlugin(const WebPluginInfo& info);
+  // plugins is the list of plugins we have crawled in the current plugin
+  // loading run.
+  bool ShouldLoadPlugin(const WebPluginInfo& info,
+                        std::vector<WebPluginInfo>* plugins);
 
   // Load internal plugins.
-  void LoadInternalPlugins();
+  void LoadInternalPlugins(std::vector<WebPluginInfo>* plugins);
 
   // Find a plugin by mime type, and clsid.
   // If clsid is empty, we will just find the plugin that supports mime type.
   // Otherwise, if mime_type is application/x-oleobject etc that's supported by
   // by our activex shim, we need to check if the specified ActiveX exists.
   // If not we will not return the activex shim, instead we will let the
   // default plugin handle activex installation.
   // The allow_wildcard parameter controls whether this function returns
   // plugins which support wildcard mime types (* as the mime type)
   bool FindPlugin(const std::string &mime_type, const std::string& clsid,
@@ skipping 51 matching lines @@
 
   // Extra plugin paths that we want to search when loading.
   std::vector<FilePath> extra_plugin_paths_;
 
   // Extra plugin directories that we want to search when loading.
   std::vector<FilePath> extra_plugin_dirs_;
 
   // Holds information about internal plugins.
   std::vector<PluginVersionInfo> internal_plugins_;
 
+  // Need synchronization for the above members since this object can be
+  // accessed on multiple threads.
+  Lock lock_;
+
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
-  DISALLOW_EVIL_CONSTRUCTORS(PluginList);
+  DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 } // namespace NPAPI
 
 #endif  // WEBKIT_GLUE_PLUGIN_PLUGIN_LIST_H__