| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_ | |
| 6 #define WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_ | |
| 7 | |
| 8 #include <set> | |
| 9 #include <string> | |
| 10 #include <utility> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "base/basictypes.h" | |
| 14 #include "base/callback.h" | |
| 15 #include "base/files/file_path.h" | |
| 16 #include "base/lazy_instance.h" | |
| 17 #include "base/memory/linked_ptr.h" | |
| 18 #include "base/memory/scoped_vector.h" | |
| 19 #include "base/synchronization/lock.h" | |
| 20 #include "webkit/plugins/webkit_plugins_export.h" | |
| 21 #include "webkit/plugins/webplugininfo.h" | |
| 22 | |
| 23 class GURL; | |
| 24 | |
| 25 namespace webkit { | |
| 26 namespace npapi { | |
| 27 | |
| 28 // The PluginList is responsible for loading our NPAPI based plugins. It does | |
| 29 // so in whatever manner is appropriate for the platform. On Windows, it loads | |
| 30 // plugins from a known directory by looking for DLLs which start with "NP", | |
| 31 // and checking to see if they are valid NPAPI libraries. On the Mac, it walks | |
| 32 // the machine-wide and user plugin directories and loads anything that has | |
| 33 // the correct types. On Linux, it walks the plugin directories as well | |
| 34 // (e.g. /usr/lib/browser-plugins/). | |
| 35 // This object is thread safe. | |
| 36 class PluginList { | |
| 37 public: | |
| 38 | |
| 39 // Gets the one instance of the PluginList. | |
| 40 static PluginList* Singleton(); | |
| 41 | |
| 42 // Returns true if we're in debug-plugin-loading mode. This is controlled | |
| 43 // by a command line switch. | |
| 44 static bool DebugPluginLoading(); | |
| 45 | |
| 46 // Returns true if the plugin supports |mime_type|. |mime_type| should be all | |
| 47 // lower case. | |
| 48 static bool SupportsType(const webkit::WebPluginInfo& plugin, | |
| 49 const std::string& mime_type, | |
| 50 bool allow_wildcard); | |
| 51 | |
| 52 // Disables discovery of third_party plugins in standard places next time | |
| 53 // plugins are loaded. | |
| 54 void DisablePluginsDiscovery(); | |
| 55 | |
| 56 // Cause the plugin list to refresh next time they are accessed, regardless | |
| 57 // of whether they are already loaded. | |
| 58 void RefreshPlugins(); | |
| 59 | |
| 60 // Add/Remove an extra plugin to load when we actually do the loading. Must | |
| 61 // be called before the plugins have been loaded. | |
| 62 void AddExtraPluginPath(const base::FilePath& plugin_path); | |
| 63 void RemoveExtraPluginPath(const base::FilePath& plugin_path); | |
| 64 | |
| 65 // Same as above, but specifies a directory in which to search for plugins. | |
| 66 void AddExtraPluginDir(const base::FilePath& plugin_dir); | |
| 67 | |
| 68 // Get the ordered list of directories from which to load plugins | |
| 69 void GetPluginDirectories(std::vector<base::FilePath>* plugin_dirs); | |
| 70 | |
| 71 // Register an internal plugin with the specified plugin information. | |
| 72 // An internal plugin must be registered before it can | |
| 73 // be loaded using PluginList::LoadPlugin(). | |
| 74 // If |add_at_beginning| is true the plugin will be added earlier in | |
| 75 // the list so that it can override the MIME types of older registrations. | |
| 76 void RegisterInternalPlugin(const webkit::WebPluginInfo& info, | |
| 77 bool add_at_beginning); | |
| 78 | |
| 79 // Removes a specified internal plugin from the list. The search will match | |
| 80 // on the path from the version info previously registered. | |
| 81 void UnregisterInternalPlugin(const base::FilePath& path); | |
| 82 | |
| 83 // Gets a list of all the registered internal plugins. | |
| 84 void GetInternalPlugins(std::vector<webkit::WebPluginInfo>* plugins); | |
| 85 | |
| 86 // Creates a WebPluginInfo structure given a plugin's path. On success | |
| 87 // returns true, with the information being put into "info". | |
| 88 // Returns false if the library couldn't be found, or if it's not a plugin. | |
| 89 bool ReadPluginInfo(const base::FilePath& filename, | |
| 90 webkit::WebPluginInfo* info); | |
| 91 | |
| 92 // In Windows plugins, the mime types are passed as a specially formatted list | |
| 93 // of strings. This function parses those strings into a WebPluginMimeType | |
| 94 // vector. | |
| 95 // TODO(evan): move this code into plugin_list_win. | |
| 96 static bool ParseMimeTypes( | |
| 97 const std::string& mime_types, | |
| 98 const std::string& file_extensions, | |
| 99 const base::string16& mime_type_descriptions, | |
| 100 std::vector<webkit::WebPluginMimeType>* parsed_mime_types); | |
| 101 | |
| 102 // Get all the plugins synchronously, loading them if necessary. | |
| 103 void GetPlugins(std::vector<webkit::WebPluginInfo>* plugins); | |
| 104 | |
| 105 // Copies the list of plug-ins into |plugins| without loading them. | |
| 106 // Returns true if the list of plugins is up-to-date. | |
| 107 bool GetPluginsNoRefresh( | |
| 108 std::vector<webkit::WebPluginInfo>* plugins); | |
| 109 | |
| 110 // Returns a list in |info| containing plugins that are found for | |
| 111 // the given url and mime type (including disabled plugins, for | |
| 112 // which |info->enabled| is false). The mime type which corresponds | |
| 113 // to the URL is optionally returned back in |actual_mime_types| (if | |
| 114 // it is non-NULL), one for each of the plugin info objects found. | |
| 115 // The |allow_wildcard| parameter controls whether this function | |
| 116 // returns plugins which support wildcard mime types (* as the mime | |
| 117 // type). The |info| parameter is required to be non-NULL. The | |
| 118 // list is in order of "most desirable" to "least desirable". | |
| 119 // If |use_stale| is NULL, this will load the plug-in list if necessary. | |
| 120 // If it is not NULL, the plug-in list will not be loaded, and |*use_stale| | |
| 121 // will be true iff the plug-in list was stale. | |
| 122 void GetPluginInfoArray(const GURL& url, | |
| 123 const std::string& mime_type, | |
| 124 bool allow_wildcard, | |
| 125 bool* use_stale, | |
| 126 std::vector<webkit::WebPluginInfo>* info, | |
| 127 std::vector<std::string>* actual_mime_types); | |
| 128 | |
| 129 // Load a specific plugin with full path. Return true iff loading the plug-in | |
| 130 // was successful. | |
| 131 bool LoadPluginIntoPluginList(const base::FilePath& filename, | |
| 132 std::vector<webkit::WebPluginInfo>* plugins, | |
| 133 webkit::WebPluginInfo* plugin_info); | |
| 134 | |
| 135 // The following functions are used to support probing for WebPluginInfo | |
| 136 // using a different instance of this class. | |
| 137 | |
| 138 // Computes a list of all plugins to potentially load from all sources. | |
| 139 void GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths); | |
| 140 | |
| 141 // Clears the internal list of Plugins and copies them from the vector. | |
| 142 void SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins); | |
| 143 | |
| 144 void set_will_load_plugins_callback(const base::Closure& callback); | |
| 145 | |
| 146 virtual ~PluginList(); | |
| 147 | |
| 148 // Creates a WebPluginInfo structure given a plugin's path. On success | |
| 149 // returns true, with the information being put into "info". | |
| 150 // Returns false if the library couldn't be found, or if it's not a plugin. | |
| 151 static bool ReadWebPluginInfo(const base::FilePath& filename, | |
| 152 webkit::WebPluginInfo* info); | |
| 153 | |
| 154 #if defined(OS_POSIX) && !defined(OS_MACOSX) | |
| 155 // Parse the result of an NP_GetMIMEDescription() call. | |
| 156 // This API is only used on Unixes, and is exposed here for testing. | |
| 157 static void ParseMIMEDescription(const std::string& description, | |
| 158 std::vector<webkit::WebPluginMimeType>* mime_types); | |
| 159 | |
| 160 // Extract a version number from a description string. | |
| 161 // This API is only used on Unixes, and is exposed here for testing. | |
| 162 static void ExtractVersionString(const std::string& version, | |
| 163 webkit::WebPluginInfo* info); | |
| 164 #endif | |
| 165 | |
| 166 private: | |
| 167 enum LoadingState { | |
| 168 LOADING_STATE_NEEDS_REFRESH, | |
| 169 LOADING_STATE_REFRESHING, | |
| 170 LOADING_STATE_UP_TO_DATE, | |
| 171 }; | |
| 172 | |
| 173 friend class PluginListTest; | |
| 174 friend struct base::DefaultLazyInstanceTraits<PluginList>; | |
| 175 | |
| 176 PluginList(); | |
| 177 | |
| 178 // Implements all IO dependent operations of the LoadPlugins method so that | |
| 179 // test classes can mock these out. | |
| 180 virtual void LoadPluginsIntoPluginListInternal( | |
| 181 std::vector<webkit::WebPluginInfo>* plugins); | |
| 182 | |
| 183 // Load all plugins from the default plugins directory. | |
| 184 void LoadPlugins(); | |
| 185 | |
| 186 // Walks a directory and produces a list of all the plugins to potentially | |
| 187 // load in that directory. | |
| 188 void GetPluginsInDir(const base::FilePath& path, | |
| 189 std::vector<base::FilePath>* plugins); | |
| 190 | |
| 191 // Returns true if we should load the given plugin, or false otherwise. | |
| 192 // |plugins| is the list of plugins we have crawled in the current plugin | |
| 193 // loading run. | |
| 194 bool ShouldLoadPluginUsingPluginList( | |
| 195 const webkit::WebPluginInfo& info, | |
| 196 std::vector<webkit::WebPluginInfo>* plugins); | |
| 197 | |
| 198 // Returns true if the given plugin supports a given file extension. | |
| 199 // |extension| should be all lower case. If |mime_type| is not NULL, it will | |
| 200 // be set to the MIME type if found. The MIME type which corresponds to the | |
| 201 // extension is optionally returned back. | |
| 202 bool SupportsExtension(const webkit::WebPluginInfo& plugin, | |
| 203 const std::string& extension, | |
| 204 std::string* actual_mime_type); | |
| 205 // | |
| 206 // Command-line switches | |
| 207 // | |
| 208 | |
| 209 #if defined(OS_WIN) | |
| 210 // Gets plugin paths registered under HKCU\Software\MozillaPlugins and | |
| 211 // HKLM\Software\MozillaPlugins. | |
| 212 void GetPluginPathsFromRegistry(std::vector<base::FilePath>* plugins); | |
| 213 #endif | |
| 214 | |
| 215 // | |
| 216 // Internals | |
| 217 // | |
| 218 | |
| 219 // States whether we will load the plug-in list the next time we try to access | |
| 220 // it, whether we are currently in the process of loading it, or whether we | |
| 221 // consider it up-to-date. | |
| 222 LoadingState loading_state_; | |
| 223 | |
| 224 // Extra plugin paths that we want to search when loading. | |
| 225 std::vector<base::FilePath> extra_plugin_paths_; | |
| 226 | |
| 227 // Extra plugin directories that we want to search when loading. | |
| 228 std::vector<base::FilePath> extra_plugin_dirs_; | |
| 229 | |
| 230 // Holds information about internal plugins. | |
| 231 std::vector<webkit::WebPluginInfo> internal_plugins_; | |
| 232 | |
| 233 // A list holding all plug-ins. | |
| 234 std::vector<webkit::WebPluginInfo> plugins_list_; | |
| 235 | |
| 236 // Callback that is invoked whenever the PluginList will reload the plugins. | |
| 237 base::Closure will_load_plugins_callback_; | |
| 238 | |
| 239 // Need synchronization for the above members since this object can be | |
| 240 // accessed on multiple threads. | |
| 241 base::Lock lock_; | |
| 242 | |
| 243 // Flag indicating whether third_party plugins will be searched for | |
| 244 // in common places. | |
| 245 bool plugins_discovery_disabled_; | |
| 246 | |
| 247 DISALLOW_COPY_AND_ASSIGN(PluginList); | |
| 248 }; | |
| 249 | |
| 250 } // namespace npapi | |
| 251 } // namespace webkit | |
| 252 | |
| 253 #endif // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 19761007:
Move NPAPI implementation out of webkit/plugins/npapi and into content. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/