plugins: drop PluginVersionInfo for internal plugins

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 <vector>
@@ skipping 25 matching lines @@
 // This struct holds entry points into a plugin.  The entry points are
 // slightly different between Win/Mac and Unixes.
 struct PluginEntryPoints {
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
   NP_GetEntryPointsFunc np_getentrypoints;
 #endif
   NP_InitializeFunc np_initialize;
   NP_ShutdownFunc np_shutdown;
 };
 
-// This struct fully describes a plugin. For external plugins, it's read in from
-// the version info of the dll; For internal plugins, it's predefined and
-// includes addresses of entry functions. (Yes, it's Win32 NPAPI-centric, but
-// it'll do for holding descriptions of internal plugins cross-platform.)
-// TODO(evan): remove when NaCl is fixed.
-struct PluginVersionInfo {
-  FilePath path;
-  // Info about the plugin itself.
-  std::wstring product_name;
-  std::wstring file_description;
-  std::wstring file_version;
-  // Info about the data types that the plugin supports.
-  std::wstring mime_types;
-  std::wstring file_extensions;
-  std::wstring type_descriptions;
-  // Entry points for internal plugins.  Pointers are NULL for external plugins.
-  PluginEntryPoints entry_points;
-};
-
 // 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:
@@ skipping 17 matching lines @@
   // Add/Remove an extra plugin to load when we actually do the loading.  Must
   // be called before the plugins have been loaded.
   void AddExtraPluginPath(const FilePath& plugin_path);
   void RemoveExtraPluginPath(const FilePath& plugin_path);
 
   // Same as above, but specifies a directory in which to search for plugins.
   void AddExtraPluginDir(const FilePath& plugin_dir);
 
   // Register an internal plugin with the specified plugin information and
   // function pointers.  An internal plugin must be registered before it can
   // be loaded using PluginList::LoadPlugin().

[pastarmovj, 2011/01/13 13:36:08]

Maybe fix this comment because it used to cover both versions and now you have
comments for each.

-  void RegisterInternalPlugin(const FilePath& path);
+  void RegisterInternalPlugin(const WebPluginInfo& info);
+  // This second version is for "plugins" that have been compiled
+  // directly into the binary -- callers must provide the metadata and
+  // the entry points.
+  // TODO(evan): we use file names here, but they're not really files, they're
+  // actually a string that uniquely identifies the plugin.
   void RegisterInternalPlugin(const FilePath& filename,
                               const std::string& name,
                               const std::string& description,
                               const std::string& mime_type,
                               const PluginEntryPoints& entry_points);
 
-  // Deprecated version of the above.
-  // TODO(evan): remove when NaCl is fixed.
-  void RegisterInternalPlugin(const PluginVersionInfo& info);
-
   // Removes a specified internal plugin from the list. The search will match
   // on the path from the version info previously registered.
   //
   // This is generally only necessary for tests.
   void UnregisterInternalPlugin(const FilePath& path);
 
   // Creates a WebPluginInfo structure given a plugin's path.  On success
   // returns true, with the information being put into "info".  If it's an
   // internal plugin, "entry_points" is filled in as well with a
   // internally-owned PluginEntryPoints pointer.
   // Returns false if the library couldn't be found, or if it's not a plugin.
   bool ReadPluginInfo(const FilePath& filename,
                       WebPluginInfo* info,
                       const PluginEntryPoints** entry_points);
 
-  // Populate a WebPluginInfo from a PluginVersionInfo.
-  static bool CreateWebPluginInfo(const PluginVersionInfo& pvi,
-                                  WebPluginInfo* info);
+  // 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);
 
@@ skipping 169 matching lines @@
 
   // 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<PluginVersionInfo> 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.
   Lock lock_;
 
   friend struct base::DefaultLazyInstanceTraits<PluginList>;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_