Remove PluginGroup

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>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
+#include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/lock.h"
 #include "third_party/npapi/bindings/nphostapi.h"
-#include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/webkit_plugins_export.h"
 #include "webkit/plugins/webplugininfo.h"
 
 class GURL;
 
-namespace base {
-
-template <typename T>
-struct DefaultLazyInstanceTraits;
-
-}  // namespace base
-
 namespace webkit {
 namespace npapi {
 
 // This struct holds entry points into a plugin.  The entry points are
 // slightly different between Win/Mac and Unixes.  Note that the interface for
 // querying plugins is synchronous and it is preferable to use a higher-level
 // asynchronous information to query information.
 struct PluginEntryPoints {
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
   NP_GetEntryPointsFunc np_getentrypoints;
 #endif
   NP_InitializeFunc np_initialize;
   NP_ShutdownFunc np_shutdown;
 };
 
 // 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 WEBKIT_PLUGINS_EXPORT PluginList {
  public:
+  // Custom traits that performs platform-dependent initialization
+  // when the instance is created.
+  struct CustomLazyInstanceTraits

[Bernhard Bauer, 2012/09/20 17:03:00]

I think you could forward-declare the struct, move it to the private section,
and move the class definition to the .cc file as well?

[ibraaaa, 2012/09/21 09:24:57]

If I understand correctly, then you mean:

.h file:

private:
 struct CustomLazyInstanceTraits;

.cc file

struct PluginList::CustomLazyInstanceTraits {
.....
}

if this is right, then I guess CustomLazyInstanceTraits will not be visible
anymore? 

On 2012/09/20 17:03:00, Bernhard Bauer wrote:

[Bernhard Bauer, 2012/09/21 09:33:52]

Yes, it will only be forward-declared for other classes, but that's okay,
because it's only being used by the LazyInstance in the .cc file, which isn't
externally visible either, right?

[ibraaaa, 2012/09/21 09:37:56]

yes but the LazyInstance in the .cc file is declared in an anonymous namespace
and it needs as part of its declaration 
LazyInstance<PluginList, PluginList::CustomLazyInstanceTraits> g_singleton =...;

if CustomLazyInstanceTraits is not visible then this won't work?

On 2012/09/21 09:33:52, Bernhard Bauer wrote:

[Bernhard Bauer, 2012/09/21 09:53:28]

Ah, you meant visible in the 'public'/'private' sense? Right, we might need to
keep the declaration in the public section.

+      : base::DefaultLazyInstanceTraits<PluginList> {
+    static PluginList* New(void* instance);
+  };
+
   // 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();
 
   // Cause the plugin list to refresh next time they are accessed, regardless
   // of whether they are already loaded.
   void RefreshPlugins();
@@ skipping 73 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.
+  // Clears the internal list of Plugins 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);
+  // Constructors are private for singletons but we expose this one
+  // for subclasses for test purposes.
+  PluginList();
 
  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,
@@ skipping 43 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_