Make WebPluginInfo more generic

webkit/plugins/npapi/plugin_group.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_GROUP_H_
 #define WEBKIT_PLUGINS_NPAPI_PLUGIN_GROUP_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
-#include "webkit/plugins/npapi/webplugininfo.h"
+#include "webkit/plugins/webplugininfo.h"
 
 class FilePath;
 class PluginExceptionsTableModelTest;
 class Version;
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace webkit {
@@ skipping 81 matching lines @@
 
   // Tests whether |plugin_name| within the plugin group |group_name| is
   // disabled by policy.
   static bool IsPluginFileNameDisabledByPolicy(const string16& plugin_name,
                                                const string16& group_name);
 
   // Tests whether |plugin_name| is enabled by policy.
   static bool IsPluginNameEnabledByPolicy(const string16& plugin_name);
 
   // Returns true if the given plugin matches this group.
-  bool Match(const WebPluginInfo& plugin) const;
+  bool Match(const webkit::WebPluginInfo& plugin) const;
 
   // Adds the given plugin to this group.
-  void AddPlugin(const WebPluginInfo& plugin);
+  void AddPlugin(const webkit::WebPluginInfo& plugin);
 
   // Removes a plugin from the group by its path.
   bool RemovePlugin(const FilePath& filename);
 
   // The two following functions enable/disable a plugin given its filename. The
   // function returns true if the plugin could be enabled/disabled. Plugins
   // might not get enabled/disabled if they are controlled by policy or are
   // already in the wanted state.
   bool EnablePlugin(const FilePath& filename);
   bool DisablePlugin(const FilePath& filename);
@@ skipping 16 matching lines @@
   // Sets a unique identifier for this group or if none is set an empty string.
   void set_identifier(const std::string& identifier) {
     identifier_ = identifier;
   }
 
   // Returns this group's name, or the filename without extension if the name
   // is empty.
   string16 GetGroupName() const;
 
   // Returns all plugins added to the group.
-  const std::vector<WebPluginInfo>& web_plugins_info() const {
+  const std::vector<webkit::WebPluginInfo>& web_plugins_info() const {
     return web_plugin_infos_;
   }
 
   // Checks whether a plugin exists in the group with the given path.
   bool ContainsPlugin(const FilePath& path) const;
 
   // Returns the description of the highest-priority plug-in in the group.
   const string16& description() const { return description_; }
 
   // Returns a DictionaryValue with data to display in the UI.
@@ skipping 21 matching lines @@
   bool IsEmpty() const;
 
   // Disables all plugins in this group that are older than the
   // minimum version.
   void DisableOutdatedPlugins();
 
   // Parse a version string as used by a plug-in. This method is more lenient
   // in accepting weird version strings than Version::GetFromString().
   static Version* CreateVersionFromString(const string16& version_string);
 
-  std::vector<WebPluginInfo> web_plugin_infos() { return web_plugin_infos_; }
+  std::vector<webkit::WebPluginInfo> web_plugin_infos() {
+    return web_plugin_infos_;
+  }
 
  private:
   friend class PluginList;
   friend class MockPluginList;
   friend class PluginGroupTest;
   friend class ::PluginExceptionsTableModelTest;
   FRIEND_TEST_ALL_PREFIXES(PluginListTest, DisableOutdated);
 
   // Generates the (short) identifier string for the given plugin.
-  static std::string GetIdentifier(const WebPluginInfo& wpi);
+  static std::string GetIdentifier(const webkit::WebPluginInfo& wpi);
 
   // Generates the long identifier (based on the full file path) for the given
   // plugin, to be called when the short identifier is not unique.
-  static std::string GetLongIdentifier(const WebPluginInfo& wpi);
+  static std::string GetLongIdentifier(const webkit::WebPluginInfo& wpi);
 
   // Creates a PluginGroup from a PluginGroupDefinition. The caller takes
   // ownership of the created PluginGroup.
   static PluginGroup* FromPluginGroupDefinition(
       const PluginGroupDefinition& definition);
 
   // Creates a PluginGroup from a WebPluginInfo. The caller takes ownership of
   // the created PluginGroup.
-  static PluginGroup* FromWebPluginInfo(const WebPluginInfo& wpi);
+  static PluginGroup* FromWebPluginInfo(const webkit::WebPluginInfo& wpi);
 
   // Returns |true| if |version| is contained in [low, high) of |range|.
   static bool IsVersionInRange(const Version& version,
                                const VersionRange& range);
 
   // Returns |true| iff |plugin_version| is both contained in |version_range|
   // and declared outdated (== vulnerable) by it.
   static bool IsPluginOutdated(const Version& plugin_version,
                                const VersionRange& version_range);
 
   PluginGroup(const string16& group_name,
               const string16& name_matcher,
               const std::string& update_url,
               const std::string& identifier);
 
   void InitFrom(const PluginGroup& other);
 
   // Set the description and version for this plugin group from the
   // given plug-in.
-  void UpdateDescriptionAndVersion(const WebPluginInfo& plugin);
+  void UpdateDescriptionAndVersion(const webkit::WebPluginInfo& plugin);
 
   // Updates the active plugin in the group. The active plugin is the first
   // enabled one, or if all plugins are disabled, simply the first one.
-  void UpdateActivePlugin(const WebPluginInfo& plugin);
+  void UpdateActivePlugin(const webkit::WebPluginInfo& plugin);
 
   // Resets the group state to its default value (as if the group was empty).
   // After calling this method, calling |UpdateActivePlugin| with all plugins
   // in a row will correctly set the group state.
   void ResetGroupState();
 
   // Enables the plugin if not already enabled and if policy allows it to.
   // Returns true on success. Does not update the group state.
-  static bool Enable(WebPluginInfo* plugin, int reason);
+  static bool Enable(webkit::WebPluginInfo* plugin, int reason);
 
   // Disables the plugin if not already disabled and if policy allows it to.
   // Returns true on success. Does not update the group state.
-  static bool Disable(WebPluginInfo* plugin, int reason);
+  static bool Disable(webkit::WebPluginInfo* plugin, int reason);
 
   // Helper function to implement the functions above.
-  static bool SetPluginState(WebPluginInfo* plugin,
+  static bool SetPluginState(webkit::WebPluginInfo* plugin,
                              int new_reason,
                              bool state_changes);
 
   // Returns a non-const vector of all plugins in the group. This is only used
   // by PluginList.
-  std::vector<WebPluginInfo>& GetPluginsContainer() {
+  std::vector<webkit::WebPluginInfo>& GetPluginsContainer() {
     return web_plugin_infos_;
   }
 
   // Checks if |name| matches any of the patterns in |pattern_set|.
   static bool IsStringMatchedInSet(const string16& name,
                                    const std::set<string16>* pattern_set);
 
   static std::set<string16>* policy_disabled_plugin_patterns_;
   static std::set<string16>* policy_disabled_plugin_exception_patterns_;
   static std::set<string16>* policy_enabled_plugin_patterns_;
 
   std::string identifier_;
   string16 group_name_;
   string16 name_matcher_;
   string16 description_;
   std::string update_url_;
   bool enabled_;
   std::vector<VersionRange> version_ranges_;
   scoped_ptr<Version> version_;
-  std::vector<WebPluginInfo> web_plugin_infos_;
+  std::vector<webkit::WebPluginInfo> web_plugin_infos_;
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_GROUP_H_