Remove webkit/plugins/npapi.

content/common/plugin_list.h

 // 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.
 
 #ifndef CONTENT_COMMON_PLUGIN_LIST_H_
 #define CONTENT_COMMON_PLUGIN_LIST_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 81 matching lines @@
   // of strings. This function parses those strings into a WebPluginMimeType
   // vector.
   // TODO(evan): move this code into plugin_list_win.
   static bool ParseMimeTypes(
       const std::string& mime_types,
       const std::string& file_extensions,
       const base::string16& mime_type_descriptions,
       std::vector<webkit::WebPluginMimeType>* parsed_mime_types);
 
   // Get all the plugins synchronously, loading them if necessary.
-  void GetPlugins(std::vector<webkit::WebPluginInfo>* plugins);
+  void GetPlugins(std::vector<webkit::WebPluginInfo>* plugins,
+                  bool include_npapi);
 
   // Copies the list of plug-ins into |plugins| without loading them.
   // Returns true if the list of plugins is up-to-date.
   bool GetPluginsNoRefresh(
       std::vector<webkit::WebPluginInfo>* plugins);
 
   // Returns a list in |info| containing plugins that are found for
   // the given url and mime type (including disabled plugins, for
   // which |info->enabled| is false).  The mime type which corresponds
   // to the URL is optionally returned back in |actual_mime_types| (if
   // it is non-NULL), one for each of the plugin info objects found.
   // The |allow_wildcard| parameter controls whether this function
   // returns plugins which support wildcard mime types (* as the mime
   // type).  The |info| parameter is required to be non-NULL.  The
   // list is in order of "most desirable" to "least desirable".
   // If |use_stale| is NULL, this will load the plug-in list if necessary.
   // If it is not NULL, the plug-in list will not be loaded, and |*use_stale|
   // will be true iff the plug-in list was stale.
   void 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);
 
   // Load a specific plugin with full path. Return true iff loading the plug-in
   // was successful.
   bool LoadPluginIntoPluginList(const base::FilePath& filename,
                                 std::vector<webkit::WebPluginInfo>* plugins,
                                 webkit::WebPluginInfo* plugin_info);
 
   // The following functions are used to support probing for WebPluginInfo
   // using a different instance of this class.
 
   // Computes a list of all plugins to potentially load from all sources.
-  void GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths);
+  void GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths,
+                            bool include_npapi);
 
   // Clears the internal list of Plugins and copies them from the vector.
   void SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
 
   void set_will_load_plugins_callback(const base::Closure& callback);
 
   virtual ~PluginList();
 
   // Creates a WebPluginInfo structure given a plugin's path.  On success
   // returns true, with the information being put into "info".
@@ skipping 18 matching lines @@
     LOADING_STATE_NEEDS_REFRESH,
     LOADING_STATE_REFRESHING,
     LOADING_STATE_UP_TO_DATE,
   };
 
   friend class PluginListTest;
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
   PluginList();
 
-  // Implements all IO dependent operations of the LoadPlugins method so that
-  // test classes can mock these out.
-  virtual void LoadPluginsIntoPluginListInternal(
-      std::vector<webkit::WebPluginInfo>* plugins);
-
   // Load all plugins from the default plugins directory.
-  void LoadPlugins();
+  void LoadPlugins(bool include_npapi);
 
   // Walks a directory and produces a list of all the plugins to potentially
   // load in that directory.
   void GetPluginsInDir(const base::FilePath& path,
                        std::vector<base::FilePath>* plugins);
 
   // Returns true if we should load the given plugin, or false otherwise.
   // |plugins| is the list of plugins we have crawled in the current plugin
   // loading run.
   bool ShouldLoadPluginUsingPluginList(
@@ skipping 48 matching lines @@
   // Flag indicating whether third_party plugins will be searched for
   // in common places.
   bool plugins_discovery_disabled_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_PLUGIN_LIST_H_