1st CL in a series to remove PluginGroup. Updates PluginList.

webkit/plugins/npapi/plugin_list.h

 // Copyright (c) 2012 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 130 matching lines @@
   // 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<webkit::WebPluginInfo>* info,
                           std::vector<std::string>* actual_mime_types);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Populates the given vector with all available plugin groups. If
   // |load_if_necessary| is true, this will potentially load the plugin list
   // synchronously.
   void GetPluginGroups(bool load_if_necessary,
                        std::vector<PluginGroup>* plugin_groups);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Returns a copy of the PluginGroup corresponding to the given WebPluginInfo.
   // The caller takes ownership of the returned PluginGroup.
   PluginGroup* GetPluginGroup(const webkit::WebPluginInfo& web_plugin_info);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Returns the name of the PluginGroup with the given identifier.
   // If no such group exists, an empty string is returned.
   string16 GetPluginGroupName(const std::string& identifier);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Load a specific plugin with full path. Return true iff loading the plug-in
   // was successful.
   bool LoadPlugin(const FilePath& filename,
                   ScopedVector<PluginGroup>* plugin_groups,
                   webkit::WebPluginInfo* plugin_info);
 
+  // Load a specific plugin with full path. Return true iff loading the plug-in
+  // was successful.
+  bool LoadPluginIntoPluginList(const FilePath& filename,
+                                std::vector<webkit::WebPluginInfo>* plugins,
+                                webkit::WebPluginInfo* plugin_info);
+
   // The following functions are used to support probing for WebPluginInfo
   // using a different instance of this class.
 
   // Computes a list of all plugins to potentially load from all sources.
   void GetPluginPathsToLoad(std::vector<FilePath>* plugin_paths);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Returns the list of hardcoded plug-in groups for testing.
   const std::vector<PluginGroup*>& GetHardcodedPluginGroups() const;
 
   // Clears the internal list of PluginGroups and copies them from the vector.
   void SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
 
   void set_will_load_plugins_callback(const base::Closure& callback);
 
   virtual ~PluginList();
 
  protected:
+  // TODO(ibraaaa): DELETE and add a different one. http://crbug.com/124396
   // 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);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Adds the given WebPluginInfo to its corresponding group, creating it if
   // necessary, and returns the group.
   PluginGroup* AddToPluginGroups(const webkit::WebPluginInfo& web_plugin_info,
                                  ScopedVector<PluginGroup>* plugin_groups);
 
  private:
   enum LoadingState {
     LOADING_STATE_NEEDS_REFRESH,
     LOADING_STATE_REFRESHING,
     LOADING_STATE_UP_TO_DATE,
   };
 
   struct InternalPlugin {
     webkit::WebPluginInfo info;
     PluginEntryPoints entry_points;
   };
 
   friend class PluginListTest;
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
   FRIEND_TEST_ALL_PREFIXES(PluginGroupTest, PluginGroupDefinition);
 
   // Constructors are private for singletons.
   PluginList();
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Creates PluginGroups for the hardcoded group definitions, and stores them
   // in |hardcoded_plugin_groups_|.
   void AddHardcodedPluginGroups(const PluginGroupDefinition* group_definitions,
                                 size_t num_group_definitions);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Creates a new PluginGroup either from a hardcoded group definition, or from
   // the plug-in information.
   // Caller takes ownership of the returned PluginGroup.
   PluginGroup* CreatePluginGroup(
       const webkit::WebPluginInfo& web_plugin_info) const;
 
   // Implements all IO dependent operations of the LoadPlugins method so that
   // test classes can mock these out.
   virtual void LoadPluginsInternal(ScopedVector<PluginGroup>* plugin_groups);
 
+  // Implements all IO dependent operations of the LoadPlugins method so that
+  // test classes can mock these out.
+  virtual void LoadPluginsIntoPluginListInternal(
+      std::vector<webkit::WebPluginInfo>* plugins);
+
   // Load all plugins from the default plugins directory.
   void LoadPlugins();
 
   // Walks a directory and produces a list of all the plugins to potentially
   // load in that directory.
   void GetPluginsInDir(const FilePath& path, std::vector<FilePath>* plugins);
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // 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 webkit::WebPluginInfo& info,
                         ScopedVector<PluginGroup>* 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 ShouldLoadPluginUsingPluginList(
+      const webkit::WebPluginInfo& info,
+      std::vector<webkit::WebPluginInfo>* plugins);
+
   // Returns true if the plugin supports |mime_type|. |mime_type| should be all
   // lower case.
   bool SupportsType(const webkit::WebPluginInfo& plugin,
                     const std::string& mime_type,
                     bool allow_wildcard);
 
   // 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 webkit::WebPluginInfo& plugin,
                          const std::string& extension,
                          std::string* actual_mime_type);
 
+  // Removes a plug-in from |plugins_list_| by its path.
+  static bool RemovePlugin(const FilePath& filename,
+                           std::vector<webkit::WebPluginInfo>* plugins);
+
   //
   // Platform functions
   //
 
   // Do any initialization.
   void PlatformInit();
 
   //
   // Command-line switches
   //
@@ skipping 18 matching lines @@
 
   // 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<InternalPlugin> internal_plugins_;
 
+  // TODO(ibraaaa): DELETE. http://crbug.com/124396
   // Holds the currently available plugin groups.
   ScopedVector<PluginGroup> plugin_groups_;
 
   // Holds the hardcoded definitions of well-known plug-ins.
   // This should only be modified during construction of the PluginList.
   ScopedVector<PluginGroup> hardcoded_plugin_groups_;
 
+  // A list holding all plug-ins.
+  std::vector<webkit::WebPluginInfo> plugins_list_;
+
   // Callback that is invoked whenever the PluginList will reload the plugins.
   base::Closure will_load_plugins_callback_;
 
   // Need synchronization for the above members since this object can be
   // accessed on multiple threads.
   base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_