Policy: Re-enabled plugin still disabled

webkit/plugins/npapi/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_PLUGINS_NPAPI_PLUGIN_LIST_H_
 #define WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_
 
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/linked_ptr.h"
 #include "base/synchronization/lock.h"
+#include "base/scoped_vector.h"
 #include "third_party/npapi/bindings/nphostapi.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/webplugininfo.h"
 
 class GURL;
 
 namespace base {
 
 template <typename T>
 struct DefaultLazyInstanceTraits;
@@ skipping 89 matching lines @@
   // In Windows and Pepper plugins, the mime types are passed as a specially
   // formatted list of strings.  This function parses those strings into
   // a WebPluginMimeType vector.
   // TODO(evan): make Pepper pass around formatted data and 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);
 
-  // Shutdown all plugins.  Should be called at process teardown.
-  void Shutdown();
-
   // 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);
 
   // 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
@@ skipping 31 matching lines @@
   // 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);
+  string16 GetPluginGroupName(const 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);
+                  ScopedVector<PluginGroup>* plugin_groups);
 
   // 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.
+  // will be enabled.
   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);
 
   // 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.
+  // 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();
 
-  ~PluginList();
+  virtual ~PluginList();
+
+ protected:
+  // Constructors are private for singletons
+  PluginList();
+
+  // Load all plugins from the default plugins directory
+  virtual void LoadPlugins(bool refresh);
+
+  // Retrieves the list of currently present plugins and transfers their enabled
+  // status to the newly loaded ones. After that it checks if the
+  // |plugins_to_disable_| have entries to be disabled. Then it purges empty
+  // groups and enforces all policies active on the groups and disables outdated
+  // plugins if the user has opted for that.
+  // This function doesn't lock and depends on the caller to aquire the lock.
+  void UpdatePluginsEnabledFlags(ScopedVector<PluginGroup>* plugin_groups);
+
+  // 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,
+                                 ScopedVector<PluginGroup>* plugin_groups);
+
+  bool plugins_loaded_;
+
+  // Holds the currently available plugin groups.
+  ScopedVector<PluginGroup> plugin_groups_;
+
+  // The set of plugins that have been scheduled for disabling once they get
+  // loaded. This list is used in LoadPlugins and pruned after it. Contains
+  // plugins that were either disabled by the user (prefs are loaded before
+  // plugins) or disabled by a policy.
+  std::set<FilePath> plugins_to_disable_;
+  // Equivalent to the |prematurely_disabled_plugins_| this is the set of groups
+  // scheduled for disabling once they appear. This list is never completely
+  // pruned but all groups that do get created are removed from it. New groups
+  // might get added if they should be pruned because of plugins getting removed
+  // for example.
+  std::set<string16> groups_to_disable_;
 
  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,
+                          ScopedVector<PluginGroup>* plugin_groups,
                           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);
+                        ScopedVector<PluginGroup>* 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,
-                           const std::string &mime_type,
-                           bool allow_wildcard);
+  // Returns true if the plugin supports |mime_type|. |mime_type| should be all
+  // lower case.
+  bool SupportsType(const WebPluginInfo& plugin,
+                    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
-  // back.
-  static bool SupportsExtension(const WebPluginInfo& info,
-                                const std::string &extension,
-                                std::string* actual_mime_type);
+  // Returns true if the given plugin 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 back.
+  bool SupportsExtension(const WebPluginInfo& plugin,
+                         const std::string& extension,
+                         std::string* actual_mime_type);
 
   //
   // Platform functions
   //
 
   // Do any initialization.
   void PlatformInit();
 
   //
   // 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,
+  void LoadPluginsFromRegistry(ScopedVector<PluginGroup>* plugins,
                                std::set<FilePath>* visited_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_;
-
   // 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_;
 
   struct InternalPlugin {
     WebPluginInfo info;
     PluginEntryPoints entry_points;
   };
   // Holds information about internal plugins.
   std::vector<InternalPlugin> internal_plugins_;
 
-  // Path names of plugins to disable (the default is to enable them all).
-  std::set<FilePath> disabled_plugins_;
-
-  // 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.
   base::Lock lock_;
 
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_