Ensure we don't load plugins on the IO thread

webkit/glue/plugins/plugin_list.cc

 // 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.
 
 #include "webkit/glue/plugins/plugin_list.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/mime_util.h"
 #include "webkit/default_plugin/plugin_main.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/webkit_glue.h"
 #include "googleurl/src/gurl.h"
 
 #if defined(OS_WIN)
 #include "webkit/activex_shim/activex_shared.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #endif
 
 namespace NPAPI {
 
 base::LazyInstance<PluginList> g_singleton(base::LINKER_INITIALIZED);
 
 // static
 PluginList* PluginList::Singleton() {
-  PluginList* singleton = g_singleton.Pointer();
-  if (!singleton->plugins_loaded_) {
-    singleton->LoadPlugins(false);
-    DCHECK(singleton->plugins_loaded_);
-  }
-  return singleton;
+  return g_singleton.Pointer();
 }
 
-// static
-void PluginList::ResetPluginsLoaded() {
-  // We access the singleton directly, and not through Singleton(), since
-  // we don't want LoadPlugins() to be called.
-  g_singleton.Pointer()->plugins_loaded_ = false;
+bool PluginList::PluginsLoaded() {
+  AutoLock lock(lock_);
+  return plugins_loaded_;
 }
 
-// static
-void PluginList::AddExtraPluginPath(const FilePath& plugin_path) {
-  DCHECK(!g_singleton.Pointer()->plugins_loaded_);
-  g_singleton.Pointer()->extra_plugin_paths_.push_back(plugin_path);
+void PluginList::ResetPluginsLoaded() {
+  AutoLock lock(lock_);
+  plugins_loaded_ = false;
 }
 
-// static
+void PluginList::AddExtraPluginPath(const FilePath& plugin_path) {
+  AutoLock lock(lock_);
+  extra_plugin_paths_.push_back(plugin_path);
+}
+
 void PluginList::AddExtraPluginDir(const FilePath& plugin_dir) {
-  DCHECK(!g_singleton.Pointer()->plugins_loaded_);
-  g_singleton.Pointer()->extra_plugin_dirs_.push_back(plugin_dir);
+  AutoLock lock(lock_);
+  extra_plugin_dirs_.push_back(plugin_dir);
 }
 
 void PluginList::RegisterInternalPlugin(const PluginVersionInfo& info) {
-  DCHECK(!g_singleton.Pointer()->plugins_loaded_);
-  g_singleton.Pointer()->internal_plugins_.push_back(info);
+  AutoLock lock(lock_);
+  internal_plugins_.push_back(info);
 }
 
 bool PluginList::ReadPluginInfo(const FilePath &filename,
                                 WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
-  // We access the singleton directly, and not through Singleton(), since
-  // we might be in a LoadPlugins call and don't want to call it recursively!
-  const std::vector<PluginVersionInfo>& internal_plugins =
-      g_singleton.Pointer()->internal_plugins_;
-  for (size_t i = 0; i < internal_plugins.size(); ++i) {
-    if (filename == internal_plugins[i].path) {
-      *entry_points = &internal_plugins[i].entry_points;
-      return CreateWebPluginInfo(internal_plugins[i], info);
+  {
+    AutoLock lock(lock_);
+    for (size_t i = 0; i < internal_plugins_.size(); ++i) {
+      if (filename == internal_plugins_[i].path) {
+        *entry_points = &internal_plugins_[i].entry_points;
+        return CreateWebPluginInfo(internal_plugins_[i], info);
+      }
     }
   }
 
   // Not an internal plugin.
   *entry_points = NULL;
 
   return PluginLib::ReadWebPluginInfo(filename, info);
 }
 
 bool PluginList::CreateWebPluginInfo(const PluginVersionInfo& pvi,
@@ skipping 58 matching lines @@
       default_plugin::NP_Initialize,
       default_plugin::NP_Shutdown
     }
   };
 
   internal_plugins_.push_back(default_plugin);
 #endif
 }
 
 void PluginList::LoadPlugins(bool refresh) {
-  if (plugins_loaded_ && !refresh)
-    return;
+  // Don't want to hold the lock while loading new plugins, so we don't block
+  // other methods if they're called on other threads.
+  std::vector<FilePath> extra_plugin_paths;
+  std::vector<FilePath> extra_plugin_dirs;
+  {
+    AutoLock lock(lock_);
+    if (plugins_loaded_ && !refresh)
+      return;
 
-  plugins_.clear();
-  plugins_loaded_ = true;
+    extra_plugin_paths = extra_plugin_paths_;
+    extra_plugin_dirs = extra_plugin_dirs_;
+  }
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
+  std::vector<WebPluginInfo> new_plugins;
+
   std::vector<FilePath> directories_to_scan;
   GetPluginDirectories(&directories_to_scan);
 
-  for (size_t i = 0; i < extra_plugin_paths_.size(); ++i)
-    LoadPlugin(extra_plugin_paths_[i]);
+  for (size_t i = 0; i < extra_plugin_paths.size(); ++i)
+    LoadPlugin(extra_plugin_paths[i], &new_plugins);
 
-  for (size_t i = 0; i < extra_plugin_dirs_.size(); ++i) {
-    LoadPluginsFromDir(extra_plugin_dirs_[i]);
+  for (size_t i = 0; i < extra_plugin_dirs.size(); ++i) {
+    LoadPluginsFromDir(extra_plugin_dirs[i], &new_plugins);
   }
 
   for (size_t i = 0; i < directories_to_scan.size(); ++i) {
-    LoadPluginsFromDir(directories_to_scan[i]);
+    LoadPluginsFromDir(directories_to_scan[i], &new_plugins);
   }
 
-  LoadInternalPlugins();
+  LoadInternalPlugins(&new_plugins);
 
   if (webkit_glue::IsDefaultPluginEnabled())
-    LoadPlugin(FilePath(kDefaultPluginLibraryName));
+    LoadPlugin(FilePath(kDefaultPluginLibraryName), &new_plugins);
 
   base::TimeTicks end_time = base::TimeTicks::Now();
   base::TimeDelta elapsed = end_time - start_time;
   DLOG(INFO) << "Loaded plugin list in " << elapsed.InMilliseconds() << " ms.";
+
+  AutoLock lock(lock_);
+  plugins_ = new_plugins;
+  plugins_loaded_ = true;
 }
 
-void PluginList::LoadPlugin(const FilePath &path) {
+void PluginList::LoadPlugin(const FilePath &path,
+                            std::vector<WebPluginInfo>* plugins) {
   WebPluginInfo plugin_info;
   const PluginEntryPoints* entry_points;
 
   if (!ReadPluginInfo(path, &plugin_info, &entry_points))
     return;
 
-  if (!ShouldLoadPlugin(plugin_info))
+  if (!ShouldLoadPlugin(plugin_info, plugins))
     return;
 
   if (path.value() != kDefaultPluginLibraryName
 #if defined(OS_WIN) && !defined(NDEBUG)
       && path.BaseName().value() != L"npspy.dll"  // Make an exception for NPSPY
 #endif
       ) {
     for (size_t i = 0; i < plugin_info.mime_types.size(); ++i) {
       // TODO: don't load global handlers for now.
       // WebKit hands to the Plugin before it tries
       // to handle mimeTypes on its own.
       const std::string &mime_type = plugin_info.mime_types[i].mime_type;
       if (mime_type == "*" )
         return;
     }
   }
 
-  plugins_.push_back(plugin_info);
+  plugins->push_back(plugin_info);
 }
 
 bool PluginList::FindPlugin(const std::string& mime_type,
                             const std::string& clsid,
                             bool allow_wildcard,
                             WebPluginInfo* info) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
 
+  LoadPlugins(false);
+  AutoLock lock(lock_);
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (SupportsType(plugins_[i], mime_type, allow_wildcard)) {
 #if defined(OS_WIN)
       if (!clsid.empty() && plugins_[i].path.value() == kActiveXShimFileName) {
         // Special handling for ActiveX shim. If ActiveX is not installed, we
         // should use the default plugin to show the installation UI.
         if (!activex_shim::IsActiveXInstalled(clsid))
           continue;
       }
 #endif
       *info = plugins_[i];
       return true;
     }
   }
 
   return false;
 }
 
 bool PluginList::FindPlugin(const GURL &url, std::string* actual_mime_type,
                             WebPluginInfo* info) {
+  LoadPlugins(false);
+  AutoLock lock(lock_);
   std::string path = url.path();
   std::string::size_type last_dot = path.rfind('.');
   if (last_dot == std::string::npos)
     return false;
 
   std::string extension = StringToLowerASCII(std::string(path, last_dot+1));
 
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (SupportsExtension(plugins_[i], extension, actual_mime_type)) {
       *info = plugins_[i];
@@ skipping 34 matching lines @@
           *actual_mime_type = mime_type.mime_type;
         return true;
       }
     }
   }
 
   return false;
 }
 
 
-bool PluginList::GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins) {
-  if (refresh)
-    LoadPlugins(true);
+void PluginList::GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins) {
+  LoadPlugins(refresh);
 
+  AutoLock lock(lock_);
   *plugins = plugins_;
-
-  return true;
 }
 
 bool PluginList::GetPluginInfo(const GURL& url,
                                const std::string& mime_type,
                                const std::string& clsid,
                                bool allow_wildcard,
                                WebPluginInfo* info,
                                std::string* actual_mime_type) {
   bool found = FindPlugin(mime_type,
                           clsid,
                           allow_wildcard, info);
   if (!found
       || (info->path.value() == kDefaultPluginLibraryName
 #if defined(OS_WIN)
                                                           && clsid.empty()
 #endif
                                                                           )) {
     WebPluginInfo info2;
     if (FindPlugin(url, actual_mime_type, &info2)) {
       found = true;
       *info = info2;
     }
   }
 
   return found;
 }
 
 bool PluginList::GetPluginInfoByPath(const FilePath& plugin_path,
                                      WebPluginInfo* info) {
+  LoadPlugins(false);
+  AutoLock lock(lock_);
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (plugins_[i].path == plugin_path) {
       *info = plugins_[i];
       return true;
     }
   }
 
   return false;
 }
 
 void PluginList::Shutdown() {
   // TODO
 }
 
 } // namespace NPAPI