Policy: Re-enabled plugin still disabled

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 <utility>
 #include <vector>
 
 #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"
 
@@ skipping 44 matching lines @@
 // The PluginList is responsible for loading our NPAPI based plugins. It does
 // so in whatever manner is appropriate for the platform. On Windows, it loads
 // plugins from a known directory by looking for DLLs which start with "NP",
 // and checking to see if they are valid NPAPI libraries. On the Mac, it walks
 // the machine-wide and user plugin directories and loads anything that has
 // the correct types. On Linux, it walks the plugin directories as well
 // (e.g. /usr/lib/browser-plugins/).
 // This object is thread safe.
 class PluginList {
  public:
+  // Enum of possible reasons for plugin or group being disabled. Used in the
+  // |disabled_plugins_| and |disabled_groups_| maps.
+  enum PluginDisabledReason { USER = 0, POLICY, POLICY_AND_USER };
+  typedef std::map<FilePath, PluginDisabledReason> DisabledPlugins;
+  typedef std::map<string16, PluginDisabledReason> DisabledGroups;
+
   // 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();
 
@@ skipping 92 matching lines @@
   // 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);
+                  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.
   bool EnablePlugin(const FilePath& filename);
 
   // Disable a specific plugin, specified by path. Returns |true| iff a plugin
   // currently in the plugin list was actually disabled as a result; regardless
   // of return value, if a plugin is found in the future with the given name, it
-  // will be disabled.
-  bool DisablePlugin(const FilePath& filename);
+  // will be disabled. The boolean flag should be set to true if the plugin is
+  // disabled by a policy and not a user.
+  bool DisablePlugin(const FilePath& filename, bool policy_disabled);
 
   // Enable/disable a plugin group, specified by group_name.  Returns |true| iff
   // a plugin currently in the plugin list was actually enabled/disabled as a
   // result; regardless of return value, if a plugin is found in the future with
   // the given name, it will be enabled/disabled. Note that plugins are enabled
   // by default as far as |PluginList| is concerned.
   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();
 
-  ~PluginList();
+  const DisabledPlugins& GetDisabledPlugins() const;
+
+  const DisabledGroups& GetDisabledGroups() const;
+
+  virtual ~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);
+  PluginGroup* AddToPluginGroups(const WebPluginInfo& web_plugin_info,
+                                 std::vector<WebPluginInfo*>* plugins);
 
   // 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::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);
+                        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);
 
   // Returns true if the given WebPluginInfo supports "mime-type".
   // mime_type should be all lower case.
   static bool SupportsType(const WebPluginInfo& info,
@@ skipping 22 matching lines @@
   //
   // Command-line switches
   //
 
 #if defined(OS_WIN)
   // true if we shouldn't load the new WMP plugin.
   bool dont_load_new_wmp_;
 
   // Loads plugins registered under HKCU\Software\MozillaPlugins and
   // HKLM\Software\MozillaPlugins.
-  void LoadPluginsFromRegistry(std::vector<WebPluginInfo>* plugins,
-                               std::set<FilePath>* visited_plugins);
+  void LoadPluginsFromRegistry(std::set<FilePath>* visited_plugins,
+                               std::vector<WebPluginInfo*>* plugins);
 #endif
 
   //
   // Internals
   //
 
   bool plugins_loaded_;
 
   // If true, we reload plugins even if they've been loaded already.
   bool plugins_need_refresh_;
 
   // Contains information about the available plugins.
-  std::vector<WebPluginInfo> plugins_;
+  std::vector<WebPluginInfo*> plugins_;
 
   // Extra plugin paths that we want to search when loading.
   std::vector<FilePath> extra_plugin_paths_;
 
   // 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_;
 
+  // An element of the disabled list saves the reason for being disabled in the
+  // second element of the pair.
+  typedef std::pair<FilePath, PluginDisabledReason> DisabledPluginsListElement;
   // Path names of plugins to disable (the default is to enable them all).
-  std::set<FilePath> disabled_plugins_;
+  DisabledPlugins disabled_plugins_;
 
+  typedef std::pair<string16, PluginDisabledReason> DisabledGroupsListElement;
   // Group names to disable (the default is to enable them all).
-  std::set<string16> disabled_groups_;
+  DisabledGroups 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_;
+  mutable Lock lock_;
 
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace NPAPI
 
 #endif  // WEBKIT_GLUE_PLUGINS_PLUGIN_LIST_H_