Gracefully handle child process death in out-of-process plugin loading.

webkit/plugins/npapi/plugin_list.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 "webkit/plugins/npapi/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 239 matching lines @@
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < internal_plugins_.size(); i++) {
     if (internal_plugins_[i].info.path == path) {
       internal_plugins_.erase(internal_plugins_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
+void PluginList::GetInternalPlugins(
+    std::vector<webkit::WebPluginInfo>* internal_plugins) {
+  base::AutoLock lock(lock_);
+
+  for (std::vector<InternalPlugin>::iterator it = internal_plugins_.begin();
+       it != internal_plugins_.end();
+       ++it) {
+    internal_plugins->push_back(it->info);
+  }
+}
+
 bool PluginList::ReadPluginInfo(const FilePath& filename,
                                 webkit::WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
   {
     base::AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
       if (filename == internal_plugins_[i].info.path) {
         *entry_points = &internal_plugins_[i].entry_points;
         *info = internal_plugins_[i].info;
         return true;
@@ skipping 71 matching lines @@
       const webkit::WebPluginInfo& web_plugin_info) const {
   for (size_t i = 0; i < hardcoded_plugin_groups_.size(); ++i) {
     const PluginGroup* group = hardcoded_plugin_groups_[i];
     if (group->Match(web_plugin_info))
       return new PluginGroup(*group);
   }
   return PluginGroup::FromWebPluginInfo(web_plugin_info);
 }
 
 void PluginList::LoadPluginsInternal(ScopedVector<PluginGroup>* plugin_groups) {
-  // 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;
-  std::vector<InternalPlugin> internal_plugins;
   base::Closure will_load_callback;
   {
     base::AutoLock lock(lock_);
     // Clear the refresh bit now, because it might get set again before we
     // reach the end of the method.
     plugins_need_refresh_ = false;
     will_load_callback = will_load_plugins_callback_;
-    extra_plugin_paths = extra_plugin_paths_;
-    extra_plugin_dirs = extra_plugin_dirs_;
-    internal_plugins = internal_plugins_;
   }
 
   if (!will_load_callback.is_null())
     will_load_callback.Run();
 
-  std::set<FilePath> visited_plugins;
+  std::vector<FilePath> plugin_paths;
+  GetPluginPathsToLoad(&plugin_paths);
 
-  std::vector<FilePath> directories_to_scan;
-  GetPluginDirectories(&directories_to_scan);
-
-  // Load internal plugins first so that, if both an internal plugin and a
-  // "discovered" plugin want to handle the same type, the internal plugin
-  // will have precedence.
-  for (size_t i = 0; i < internal_plugins.size(); ++i) {
-    if (internal_plugins[i].info.path.value() == kDefaultPluginLibraryName)
-      continue;
-    LoadPlugin(internal_plugins[i].info.path, plugin_groups);
+  for (std::vector<FilePath>::const_iterator it = plugin_paths.begin();
+       it != plugin_paths.end();
+       ++it) {
+    LoadPlugin(*it, plugin_groups);
   }
-
-  for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
-    const FilePath& path = extra_plugin_paths[i];
-    if (visited_plugins.find(path) != visited_plugins.end())
-      continue;
-    LoadPlugin(path, plugin_groups);
-    visited_plugins.insert(path);
-  }
-
-  for (size_t i = 0; i < extra_plugin_dirs.size(); ++i) {
-    LoadPluginsFromDir(
-        extra_plugin_dirs[i], plugin_groups, &visited_plugins);
-  }
-
-  for (size_t i = 0; i < directories_to_scan.size(); ++i) {
-    LoadPluginsFromDir(
-        directories_to_scan[i], plugin_groups, &visited_plugins);
-  }
-
-#if defined(OS_WIN)
-  LoadPluginsFromRegistry(plugin_groups, &visited_plugins);
-#endif
-
-  // Load the default plugin last.
-  if (default_plugin_enabled_)
-    LoadPlugin(FilePath(kDefaultPluginLibraryName), plugin_groups);
 }
 
 void PluginList::LoadPlugins() {
   {
     base::AutoLock lock(lock_);
     if (!plugins_need_refresh_)
       return;
   }
 
   ScopedVector<PluginGroup> new_plugin_groups;
@@ skipping 29 matching lines @@
       const std::string &mime_type = plugin_info.mime_types[i].mime_type;
       if (mime_type == "*")
         return;
     }
   }
 
   base::AutoLock lock(lock_);
   AddToPluginGroups(plugin_info, plugin_groups);
 }
 
-void PluginList::GetPluginPathListsToLoad(
-    std::vector<FilePath>* extra_plugin_paths,
-    std::vector<FilePath>* extra_plugin_dirs,
-    std::vector<webkit::WebPluginInfo>* internal_plugins) {
-  base::AutoLock lock(lock_);
-  *extra_plugin_paths = extra_plugin_paths_;
-  *extra_plugin_dirs = extra_plugin_dirs_;
+void PluginList::GetPluginPathsToLoad(std::vector<FilePath>* plugin_paths) {
+  // 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;
+  std::vector<InternalPlugin> internal_plugins;
+  {
+    base::AutoLock lock(lock_);
+    extra_plugin_paths = extra_plugin_paths_;
+    extra_plugin_dirs = extra_plugin_dirs_;
+    internal_plugins = internal_plugins_;
+  }
 
-  *internal_plugins = std::vector<webkit::WebPluginInfo>();
-  for (std::vector<InternalPlugin>::iterator it = internal_plugins_.begin();
-       it != internal_plugins_.end();
-       ++it) {
-    internal_plugins->push_back(it->info);
+  std::vector<FilePath> directories_to_scan;
+  GetPluginDirectories(&directories_to_scan);
+
+  // Load internal plugins first so that, if both an internal plugin and a
+  // "discovered" plugin want to handle the same type, the internal plugin
+  // will have precedence.
+  for (size_t i = 0; i < internal_plugins.size(); ++i) {
+    if (internal_plugins[i].info.path.value() == kDefaultPluginLibraryName)
+      continue;
+    plugin_paths->push_back(internal_plugins[i].info.path);
   }
+
+  for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
+    const FilePath& path = extra_plugin_paths[i];
+    if (std::find(plugin_paths->begin(), plugin_paths->end(), path) !=
+        plugin_paths->end()) {
+      continue;
+    }
+    plugin_paths->push_back(path);
+  }
+
+  for (size_t i = 0; i < extra_plugin_dirs.size(); ++i)
+    GetPluginsInDir(extra_plugin_dirs[i], plugin_paths);
+
+  for (size_t i = 0; i < directories_to_scan.size(); ++i)
+    GetPluginsInDir(directories_to_scan[i], plugin_paths);
+
+#if defined(OS_WIN)
+  GetPluginPathsFromRegistry(plugin_paths);
+#endif
+
+  // Load the default plugin last.
+  if (default_plugin_enabled_)
+    plugin_paths->push_back(FilePath(kDefaultPluginLibraryName));
 }
 
 void PluginList::SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins) {
   base::AutoLock lock(lock_);
 
   plugins_need_refresh_ = false;
 
   plugin_groups_.reset();
   for (std::vector<webkit::WebPluginInfo>::const_iterator it = plugins.begin();
        it != plugins.end();
@@ skipping 227 matching lines @@
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace npapi
 }  // namespace webkit