Clean up PluginGroup and related code.

webkit/glue/plugins/plugin_list.h

 // Copyright (c) 2010 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_GLUE_PLUGINS_PLUGIN_LIST_H_
 #define WEBKIT_GLUE_PLUGINS_PLUGIN_LIST_H_
 
-#include <map>
 #include <set>
 #include <string>
 #include <vector>
-#include <set>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/linked_ptr.h"
 #include "base/lock.h"
 #include "third_party/npapi/bindings/nphostapi.h"
 #include "webkit/glue/plugins/plugin_group.h"
 #include "webkit/glue/plugins/webplugininfo.h"
 
 class GURL;
@@ skipping 50 matching lines @@
 // This object is thread safe.
 class PluginList {
  public:
   // Gets the one instance of the PluginList.
   static PluginList* Singleton();
 
   // Returns true if we're in debug-plugin-loading mode. This is controlled
   // by a command line switch.
   static bool DebugPluginLoading();
 
+  static const PluginGroupDefinition* GetPluginGroupDefinitions();
+  static size_t GetPluginGroupDefinitionsSize();
+
   // Returns true iff the plugin list has been loaded already.
   bool PluginsLoaded();
 
   // Cause the plugin list to refresh next time they are accessed, regardless
   // of whether they are already loaded.
   void RefreshPlugins();
 
   // Add/Remove an extra plugin to load when we actually do the loading.  Must
   // be called before the plugins have been loaded.
   void AddExtraPluginPath(const FilePath& plugin_path);
@@ skipping 57 matching lines @@
                      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);
 
-  typedef std::map<std::string, linked_ptr<PluginGroup> > PluginMap;
+  // Populates the given vector with all available plugin groups.
+  void GetPluginGroups(bool load_if_necessary,
+                       std::vector<PluginGroup>* plugin_groups);
 
-  // Fill the map from identifier to plugin group for all plugin groups.  If
-  // |load_if_necessary| is set, the plugins will be loaded if they haven't
-  // already been loaded, or if Refresh() has been called in the meantime;
-  // otherwise a possibly empty or stale list may be returned.
-  void GetPluginGroups(bool load_if_necessary, PluginMap* plugin_groups);
+  // Returns the PluginGroup corresponding to the given WebPluginInfo. If no
+  // such group exists, it is created and added to the cache.
+  // Beware: when calling this from the Browser process, the group that the
+  // returned pointer points to might disappear suddenly. This happens when
+  // |RefreshPlugins()| is called and then |LoadPlugins()| is triggered by a
+  // call to |GetPlugins()|, |GetEnabledPlugins()|, |GetPluginInfoArray()|,
+  // |GetPluginInfoByPath()|, or |GetPluginGroups(true, _)|. It is the caller's
+  // responsibility to make sure this doesn't happen.
+  const PluginGroup* GetPluginGroup(const WebPluginInfo& web_plugin_info);
+
+  // Returns the name of the PluginGroup with the given identifier.
+  // If no such group exists, an empty string is returned.
+  string16 GetPluginGroupName(std::string identifier);
+
+  // Returns the identifier string of the PluginGroup corresponding to the given
+  // WebPluginInfo. If no such group exists, it is created and added to the
+  // cache.
+  std::string GetPluginGroupIdentifier(const WebPluginInfo& web_plugin_info);
 
   // Load a specific plugin with full path.
   void LoadPlugin(const FilePath& filename,
                   std::vector<WebPluginInfo>* plugins);
 
   // Enable a specific plugin, specified by path. Returns |true| iff a plugin
   // currently in the plugin list was actually enabled as a result; regardless
   // of return value, if a plugin is found in the future with the given name, it
   // will be enabled. Note that plugins are enabled by default as far as
   // |PluginList| is concerned.
@@ skipping 14 matching lines @@
 
   // 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();
 
   ~PluginList();
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(PluginGroupTest, PluginGroupDefinition);
+
   // Constructors are private for singletons
   PluginList();
 
+  // Creates PluginGroups for the static group definitions, and adds them to
+  // the PluginGroup cache of this PluginList.
+  void AddHardcodedPluginGroups();
+
+  // 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.
+  PluginGroup* AddToPluginGroups(const WebPluginInfo& web_plugin_info);
+
   // Load all plugins from the default plugins directory
   void LoadPlugins(bool refresh);
 
   // 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,
                           std::vector<WebPluginInfo>* plugins,
                           std::set<FilePath>* visited_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 ShouldLoadPlugin(const WebPluginInfo& info,
                         std::vector<WebPluginInfo>* plugins);
 
   // Return whether a plug-in group with the given name should be disabled,
   // either because it already is on the list of disabled groups, or because it
   // is blacklisted by a policy. In the latter case, add the plugin group to the
   // list of disabled groups as well.
   bool ShouldDisableGroup(const string16& group_name);
 
-  // Like GetPluginGroups above, but works on a given vector of plugins.
-  static void GetPluginGroups(const std::vector<WebPluginInfo>* plugins,
-                              PluginMap* plugin_groups);
-
   // Returns true if the given WebPluginInfo supports "mime-type".
   // mime_type should be all lower case.
   static bool SupportsType(const WebPluginInfo& info,
                            const std::string &mime_type,
                            bool allow_wildcard);
 
   // Returns true if the given WebPluginInfo supports a given file extension.
   // extension should be all lower case.
   // If mime_type is not NULL, it will be set to the mime type if found.
   // The mime type which corresponds to the extension is optionally returned
@@ skipping 43 matching lines @@
 
   // Extra plugin directories that we want to search when loading.
   std::vector<FilePath> extra_plugin_dirs_;
 
   // Holds information about internal plugins.
   std::vector<PluginVersionInfo> internal_plugins_;
 
   // Path names of plugins to disable (the default is to enable them all).
   std::set<FilePath> disabled_plugins_;
 
-  // Group names disable (the default is to enable them all).
+  // Group names to disable (the default is to enable them all).
   std::set<string16> disabled_groups_;
 
   bool disable_outdated_plugins_;
 
+  // Holds the currently available plugin groups.
+  PluginGroup::PluginMap plugin_groups_;
+
+  int next_priority_;
+
   // Need synchronization for the above members since this object can be
   // accessed on multiple threads.
   Lock lock_;
 
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace NPAPI
 
 #endif  // WEBKIT_GLUE_PLUGINS_PLUGIN_LIST_H_