Remove webkit/plugins/npapi.

content/common/plugin_list.cc

 // Copyright (c) 2012 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/common/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "url/gurl.h"
-#include "webkit/plugins/npapi/plugin_utils.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
 #include "content/common/plugin_constants_win.h"
 #endif
 
 using webkit::WebPluginInfo;
 using webkit::WebPluginMimeType;
 
 namespace content {
@@ skipping 41 matching lines @@
 void PluginList::DisablePluginsDiscovery() {
   plugins_discovery_disabled_ = true;
 }
 
 void PluginList::RefreshPlugins() {
   base::AutoLock lock(lock_);
   loading_state_ = LOADING_STATE_NEEDS_REFRESH;
 }
 
 void PluginList::AddExtraPluginPath(const base::FilePath& plugin_path) {
-  if (!webkit::npapi::NPAPIPluginsSupported()) {
-    // TODO(jam): remove and just have CHECK once we're sure this doesn't get
-    // triggered.
-    DLOG(INFO) << "NPAPI plugins not supported";
-    return;
-  }
-
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_paths_.push_back(plugin_path);
 #endif
 }
 
 void PluginList::RemoveExtraPluginPath(const base::FilePath& plugin_path) {
   base::AutoLock lock(lock_);
   std::vector<base::FilePath>::iterator it =
       std::find(extra_plugin_paths_.begin(), extra_plugin_paths_.end(),
                 plugin_path);
   if (it != extra_plugin_paths_.end())
     extra_plugin_paths_.erase(it);
 }
 
 void PluginList::AddExtraPluginDir(const base::FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
 void PluginList::RegisterInternalPlugin(const webkit::WebPluginInfo& info,
                                         bool add_at_beginning) {
-  if (!webkit::npapi::NPAPIPluginsSupported() &&
-      info.type == WebPluginInfo::PLUGIN_TYPE_NPAPI) {
-    DLOG(INFO) << "Don't register NPAPI plugins when they're not supported";
-    return;
-  }
-
   base::AutoLock lock(lock_);
 
   internal_plugins_.push_back(info);
   if (add_at_beginning) {
     // Newer registrations go earlier in the list so they can override the MIME
     // types of older registrations.
     extra_plugin_paths_.insert(extra_plugin_paths_.begin(), info.path);
   } else {
     extra_plugin_paths_.push_back(info.path);
   }
@@ skipping 79 matching lines @@
   }
 
   return true;
 }
 
 PluginList::PluginList()
     : loading_state_(LOADING_STATE_NEEDS_REFRESH),
       plugins_discovery_disabled_(false) {
 }
 
-void PluginList::LoadPluginsIntoPluginListInternal(
-    std::vector<webkit::WebPluginInfo>* plugins) {
+void PluginList::LoadPlugins(bool include_npapi) {
+  {
+    base::AutoLock lock(lock_);
+    if (loading_state_ == LOADING_STATE_UP_TO_DATE)
+      return;
+
+    loading_state_ = LOADING_STATE_REFRESHING;
+  }
+
+  std::vector<webkit::WebPluginInfo> new_plugins;
   base::Closure will_load_callback;
   {
     base::AutoLock lock(lock_);
     will_load_callback = will_load_plugins_callback_;
   }
   if (!will_load_callback.is_null())
     will_load_callback.Run();
 
   std::vector<base::FilePath> plugin_paths;
-  GetPluginPathsToLoad(&plugin_paths);
+  GetPluginPathsToLoad(&plugin_paths, include_npapi);
 
   for (std::vector<base::FilePath>::const_iterator it = plugin_paths.begin();
        it != plugin_paths.end();
        ++it) {
     WebPluginInfo plugin_info;
-    LoadPluginIntoPluginList(*it, plugins, &plugin_info);
+    LoadPluginIntoPluginList(*it, &new_plugins, &plugin_info);
   }
-}
-
-void PluginList::LoadPlugins() {
-  {
-    base::AutoLock lock(lock_);
-    if (loading_state_ == LOADING_STATE_UP_TO_DATE)
-      return;
-
-    loading_state_ = LOADING_STATE_REFRESHING;
-  }
-
-  std::vector<webkit::WebPluginInfo> new_plugins;
-  // Do the actual loading of the plugins.
-  LoadPluginsIntoPluginListInternal(&new_plugins);
 
   base::AutoLock lock(lock_);
   plugins_list_.swap(new_plugins);
 
   // If we haven't been invalidated in the mean time, mark the plug-in list as
   // up-to-date.
   if (loading_state_ != LOADING_STATE_NEEDS_REFRESH)
     loading_state_ = LOADING_STATE_UP_TO_DATE;
 }
 
@@ skipping 19 matching lines @@
       // to handle mimeTypes on its own.
       const std::string &mime_type = plugin_info->mime_types[i].mime_type;
       if (mime_type == "*")
         return false;
     }
   }
   plugins->push_back(*plugin_info);
   return true;
 }
 
-void PluginList::GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths) {
+void PluginList::GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths,
+                                      bool include_npapi) {
   // 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<base::FilePath> extra_plugin_paths;
   std::vector<base::FilePath> extra_plugin_dirs;
   {
     base::AutoLock lock(lock_);
     extra_plugin_paths = extra_plugin_paths_;
     extra_plugin_dirs = extra_plugin_dirs_;
   }
 
   for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
     const base::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);
   }
 
-  if (webkit::npapi::NPAPIPluginsSupported()) {
+  if (include_npapi) {
     // A bit confusingly, this function is used to load Pepper plugins as well.
     // Those are all internal plugins so we have to use extra_plugin_paths.
     for (size_t i = 0; i < extra_plugin_dirs.size(); ++i)
       GetPluginsInDir(extra_plugin_dirs[i], plugin_paths);
 
     std::vector<base::FilePath> directories_to_scan;
     GetPluginDirectories(&directories_to_scan);
     for (size_t i = 0; i < directories_to_scan.size(); ++i)
       GetPluginsInDir(directories_to_scan[i], plugin_paths);
 
@@ skipping 11 matching lines @@
 
   plugins_list_.clear();
   plugins_list_.insert(plugins_list_.end(), plugins.begin(), plugins.end());
 }
 
 void PluginList::set_will_load_plugins_callback(const base::Closure& callback) {
   base::AutoLock lock(lock_);
   will_load_plugins_callback_ = callback;
 }
 
-void PluginList::GetPlugins(std::vector<WebPluginInfo>* plugins) {
-  LoadPlugins();
+void PluginList::GetPlugins(std::vector<WebPluginInfo>* plugins,
+                            bool include_npapi) {
+  LoadPlugins(include_npapi);
   base::AutoLock lock(lock_);
   plugins->insert(plugins->end(), plugins_list_.begin(), plugins_list_.end());
 }
 
 bool PluginList::GetPluginsNoRefresh(
     std::vector<webkit::WebPluginInfo>* plugins) {
   base::AutoLock lock(lock_);
   plugins->insert(plugins->end(), plugins_list_.begin(), plugins_list_.end());
 
   return loading_state_ == LOADING_STATE_UP_TO_DATE;
 }
 
 void PluginList::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     bool* use_stale,
+    bool include_npapi,
     std::vector<webkit::WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
   DCHECK(info);
 
   if (!use_stale)
-    LoadPlugins();
+    LoadPlugins(include_npapi);
   base::AutoLock lock(lock_);
   if (use_stale)
     *use_stale = (loading_state_ != LOADING_STATE_UP_TO_DATE);
   info->clear();
   if (actual_mime_types)
     actual_mime_types->clear();
 
   std::set<base::FilePath> visited_plugins;
 
   // Add in plugins by mime type.
@@ skipping 60 matching lines @@
     }
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace content