PluginList cleanup

webkit/plugins/npapi/plugin_list.h

 // 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.
 
 #ifndef WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_
 #define WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 100 matching lines @@
   // In Windows plugins, the mime types are passed as a specially formatted list
   // 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 string16& mime_type_descriptions,
                              std::vector<WebPluginMimeType>* parsed_mime_types);
 
   // Get all the plugins.
-  void GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins);
-
-  // Get all the enabled plugins.
-  void GetEnabledPlugins(bool refresh, std::vector<WebPluginInfo>* plugins);
+  void GetPlugins(std::vector<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",
   // meaning that the default plugin is at the end of the list.
+  // 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,
                           std::vector<WebPluginInfo>* info,
                           std::vector<std::string>* actual_mime_types);
 
-  // Returns the first item from the list returned in GetPluginInfo in |info|.
-  // Returns true if it found a match.  |actual_mime_type| may be NULL.
-  bool GetPluginInfo(const GURL& url,
-                     const std::string& mime_type,
-                     bool allow_wildcard,
-                     WebPluginInfo* info,
-                     std::string* actual_mime_type);
-
   // Get plugin info by plugin path (including disabled plugins). Returns true
   // if the plugin is found and WebPluginInfo has been filled in |info|.
   bool GetPluginInfoByPath(const FilePath& plugin_path,
                            WebPluginInfo* info);
 
   // Populates the given vector with all available plugin groups.
   void GetPluginGroups(bool load_if_necessary,
                        std::vector<PluginGroup>* plugin_groups);
 
   // Returns the PluginGroup corresponding to the given WebPluginInfo. If no
@@ skipping 36 matching lines @@
   // result; regardless of return value, if a plugin is found in the future with
   // the given name, it will be enabled/disabled.
   bool EnableGroup(bool enable, const string16& name);
 
   // Disable all plugins groups that are known to be outdated, according to
   // the information hardcoded in PluginGroup, to make sure that they can't
   // be loaded on a web page and instead show a UI to update to the latest
   // version.
   void DisableOutdatedPluginGroups();
 
-  // Returns true if the plugin list is stale, i.e. it will need to be
-  // (re)loaded on the next access.
-  bool stale() { return plugins_need_refresh_; }
-
   virtual ~PluginList();
 
  protected:
   // This constructor is used in unit tests to override the platform-dependent
   // real-world plugin group definitions with custom ones.
   PluginList(const PluginGroupDefinition* definitions, size_t num_definitions);
 
   // Adds the given WebPluginInfo to its corresponding group, creating it if
   // necessary, and returns the group.
   // Callers need to protect calls to this method by a lock themselves.
@@ skipping 11 matching lines @@
   // Creates PluginGroups for the static group definitions, and adds them to
   // the list of PluginGroups.
   void AddHardcodedPluginGroups(ScopedVector<PluginGroup>* groups);
 
   // Implements all IO dependant operations of the LoadPlugins method so that
   // test classes can mock these out. Return value false means LoadPlugins
   // should not go on with the loading.
   virtual void LoadPluginsInternal(ScopedVector<PluginGroup>* plugin_groups);
 
   // Load all plugins from the default plugins directory
-  void LoadPlugins(bool refresh);
+  void LoadPlugins();
 
   // Load all plugins from a specific directory.
   // |plugins| is updated with loaded plugin information.
   // |visited_plugins| is updated with paths to all plugins that were considered
   //   (including those we didn't load)
   void LoadPluginsFromDir(const FilePath& path,
                           ScopedVector<PluginGroup>* plugin_groups,
                           std::set<FilePath>* visited_plugins);
 
   // Returns true if we should load the given plugin, or false otherwise.
@@ skipping 92 matching lines @@
   // Set to true if the default plugin is enabled.
   bool default_plugin_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_