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 CONTENT_COMMON_PLUGIN_LIST_H_ 6 #define CONTENT_COMMON_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 "content/common/content_export.h" 21 #include "content/public/common/webplugininfo.h" 22 23 class GURL; 24 25 namespace content { 26 27 // The PluginList is responsible for loading our NPAPI based plugins. It does 28 // so in whatever manner is appropriate for the platform. On Windows, it loads 29 // plugins from a known directory by looking for DLLs which start with "NP", 30 // and checking to see if they are valid NPAPI libraries. On the Mac, it walks 31 // the machine-wide and user plugin directories and loads anything that has 32 // the correct types. On Linux, it walks the plugin directories as well 33 // (e.g. /usr/lib/browser-plugins/). 34 // This object is thread safe. 35 class CONTENT_EXPORT PluginList { 36 public: 37 38 // Gets the one instance of the PluginList. 39 static PluginList* Singleton(); 40 41 // Returns true if we're in debug-plugin-loading mode. This is controlled 42 // by a command line switch. 43 static bool DebugPluginLoading(); 44 45 // Returns true if the plugin supports |mime_type|. |mime_type| should be all 46 // lower case. 47 static bool SupportsType(const WebPluginInfo& plugin, 48 const std::string& mime_type, 49 bool allow_wildcard); 50 51 // Disables discovery of third_party plugins in standard places next time 52 // plugins are loaded. 53 void DisablePluginsDiscovery(); 54 55 // Cause the plugin list to refresh next time they are accessed, regardless 56 // of whether they are already loaded. 57 void RefreshPlugins(); 58 59 // Add/Remove an extra plugin to load when we actually do the loading. Must 60 // be called before the plugins have been loaded. 61 void AddExtraPluginPath(const base::FilePath& plugin_path); 62 void RemoveExtraPluginPath(const base::FilePath& plugin_path); 63 64 // Same as above, but specifies a directory in which to search for plugins. 65 void AddExtraPluginDir(const base::FilePath& plugin_dir); 66 67 // Get the ordered list of directories from which to load plugins 68 void GetPluginDirectories(std::vector<base::FilePath>* plugin_dirs); 69 70 // Register an internal plugin with the specified plugin information. 71 // An internal plugin must be registered before it can 72 // be loaded using PluginList::LoadPlugin(). 73 // If |add_at_beginning| is true the plugin will be added earlier in 74 // the list so that it can override the MIME types of older registrations. 75 void RegisterInternalPlugin(const WebPluginInfo& info, 76 bool add_at_beginning); 77 78 // Removes a specified internal plugin from the list. The search will match 79 // on the path from the version info previously registered. 80 void UnregisterInternalPlugin(const base::FilePath& path); 81 82 // Gets a list of all the registered internal plugins. 83 void GetInternalPlugins(std::vector<WebPluginInfo>* plugins); 84 85 // Creates a WebPluginInfo structure given a plugin's path. On success 86 // returns true, with the information being put into "info". 87 // Returns false if the library couldn't be found, or if it's not a plugin. 88 bool ReadPluginInfo(const base::FilePath& filename, 89 WebPluginInfo* info); 90 91 // In Windows plugins, the mime types are passed as a specially formatted list 92 // of strings. This function parses those strings into a WebPluginMimeType 93 // vector. 94 // TODO(evan): move this code into plugin_list_win. 95 static bool ParseMimeTypes( 96 const std::string& mime_types, 97 const std::string& file_extensions, 98 const base::string16& mime_type_descriptions, 99 std::vector<WebPluginMimeType>* parsed_mime_types); 100 101 // Get all the plugins synchronously, loading them if necessary. 102 void GetPlugins(std::vector<WebPluginInfo>* plugins, 103 bool include_npapi); 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(std::vector<WebPluginInfo>* plugins); 108 109 // Returns a list in |info| containing plugins that are found for 110 // the given url and mime type (including disabled plugins, for 111 // which |info->enabled| is false). The mime type which corresponds 112 // to the URL is optionally returned back in |actual_mime_types| (if 113 // it is non-NULL), one for each of the plugin info objects found. 114 // The |allow_wildcard| parameter controls whether this function 115 // returns plugins which support wildcard mime types (* as the mime 116 // type). The |info| parameter is required to be non-NULL. The 117 // list is in order of "most desirable" to "least desirable". 118 // If |use_stale| is NULL, this will load the plug-in list if necessary. 119 // If it is not NULL, the plug-in list will not be loaded, and |*use_stale| 120 // will be true iff the plug-in list was stale. 121 void GetPluginInfoArray(const GURL& url, 122 const std::string& mime_type, 123 bool allow_wildcard, 124 bool* use_stale, 125 bool include_npapi, 126 std::vector<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<WebPluginInfo>* plugins, 133 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 bool include_npapi); 141 142 // Clears the internal list of Plugins and copies them from the vector. 143 void SetPlugins(const std::vector<WebPluginInfo>& plugins); 144 145 void set_will_load_plugins_callback(const base::Closure& callback); 146 147 virtual ~PluginList(); 148 149 // Creates a WebPluginInfo structure given a plugin's path. On success 150 // returns true, with the information being put into "info". 151 // Returns false if the library couldn't be found, or if it's not a plugin. 152 static bool ReadWebPluginInfo(const base::FilePath& filename, 153 WebPluginInfo* info); 154 155 #if defined(OS_POSIX) && !defined(OS_MACOSX) 156 // Parse the result of an NP_GetMIMEDescription() call. 157 // This API is only used on Unixes, and is exposed here for testing. 158 static void ParseMIMEDescription(const std::string& description, 159 std::vector<WebPluginMimeType>* mime_types); 160 161 // Extract a version number from a description string. 162 // This API is only used on Unixes, and is exposed here for testing. 163 static void ExtractVersionString(const std::string& version, 164 WebPluginInfo* info); 165 #endif 166 167 private: 168 enum LoadingState { 169 LOADING_STATE_NEEDS_REFRESH, 170 LOADING_STATE_REFRESHING, 171 LOADING_STATE_UP_TO_DATE, 172 }; 173 174 friend class PluginListTest; 175 friend struct base::DefaultLazyInstanceTraits<PluginList>; 176 177 PluginList(); 178 179 // Load all plugins from the default plugins directory. 180 void LoadPlugins(bool include_npapi); 181 182 // Walks a directory and produces a list of all the plugins to potentially 183 // load in that directory. 184 void GetPluginsInDir(const base::FilePath& path, 185 std::vector<base::FilePath>* plugins); 186 187 // Returns true if we should load the given plugin, or false otherwise. 188 // |plugins| is the list of plugins we have crawled in the current plugin 189 // loading run. 190 bool ShouldLoadPluginUsingPluginList(const WebPluginInfo& info, 191 std::vector<WebPluginInfo>* plugins); 192 193 // Returns true if the given plugin supports a given file extension. 194 // |extension| should be all lower case. If |mime_type| is not NULL, it will 195 // be set to the MIME type if found. The MIME type which corresponds to the 196 // extension is optionally returned back. 197 bool SupportsExtension(const WebPluginInfo& plugin, 198 const std::string& extension, 199 std::string* actual_mime_type); 200 201 // Removes |plugin_path| from the list of extra plugin paths. Should only be 202 // called while holding |lock_|. 203 void RemoveExtraPluginPathLocked(const base::FilePath& plugin_path); 204 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<WebPluginInfo> internal_plugins_; 232 233 // A list holding all plug-ins. 234 std::vector<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 content 251 252 #endif // CONTENT_COMMON_PLUGIN_LIST_H_ 253
