| 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 #include "webkit/plugins/npapi/plugin_list.h" | |
| 6 | |
| 7 #import <Carbon/Carbon.h> | |
| 8 #import <Foundation/Foundation.h> | |
| 9 | |
| 10 #include "base/file_util.h" | |
| 11 #include "base/files/file_enumerator.h" | |
| 12 #include "base/mac/mac_util.h" | |
| 13 #include "base/mac/scoped_cftyperef.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "base/native_library.h" | |
| 16 #include "base/strings/string_number_conversions.h" | |
| 17 #include "base/strings/string_split.h" | |
| 18 #include "base/strings/string_util.h" | |
| 19 #include "base/strings/sys_string_conversions.h" | |
| 20 #include "base/strings/utf_string_conversions.h" | |
| 21 | |
| 22 using base::ScopedCFTypeRef; | |
| 23 | |
| 24 namespace webkit { | |
| 25 namespace npapi { | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 void GetPluginCommonDirectory(std::vector<base::FilePath>* plugin_dirs, | |
| 30 bool user) { | |
| 31 // Note that there are no NSSearchPathDirectory constants for these | |
| 32 // directories so we can't use Cocoa's NSSearchPathForDirectoriesInDomains(). | |
| 33 // Interestingly, Safari hard-codes the location (see | |
| 34 // WebKit/WebKit/mac/Plugins/WebPluginDatabase.mm's +_defaultPlugInPaths). | |
| 35 FSRef ref; | |
| 36 OSErr err = FSFindFolder(user ? kUserDomain : kLocalDomain, | |
| 37 kInternetPlugInFolderType, false, &ref); | |
| 38 | |
| 39 if (err) | |
| 40 return; | |
| 41 | |
| 42 plugin_dirs->push_back(base::FilePath(base::mac::PathFromFSRef(ref))); | |
| 43 } | |
| 44 | |
| 45 // Returns true if the plugin should be prevented from loading. | |
| 46 bool IsBlacklistedPlugin(const WebPluginInfo& info) { | |
| 47 // We blacklist Gears by included MIME type, since that is more stable than | |
| 48 // its name. Be careful about adding any more plugins to this list though, | |
| 49 // since it's easy to accidentally blacklist plugins that support lots of | |
| 50 // MIME types. | |
| 51 for (std::vector<WebPluginMimeType>::const_iterator i = | |
| 52 info.mime_types.begin(); i != info.mime_types.end(); ++i) { | |
| 53 // The Gears plugin is Safari-specific, so don't load it. | |
| 54 if (i->mime_type == "application/x-googlegears") | |
| 55 return true; | |
| 56 } | |
| 57 | |
| 58 // Versions of Flip4Mac 2.3 before 2.3.6 often hang the renderer, so don't | |
| 59 // load them. | |
| 60 if (StartsWith(info.name, ASCIIToUTF16("Flip4Mac Windows Media"), false) && | |
| 61 StartsWith(info.version, ASCIIToUTF16("2.3"), false)) { | |
| 62 std::vector<base::string16> components; | |
| 63 base::SplitString(info.version, '.', &components); | |
| 64 int bugfix_version = 0; | |
| 65 return (components.size() >= 3 && | |
| 66 base::StringToInt(components[2], &bugfix_version) && | |
| 67 bugfix_version < 6); | |
| 68 } | |
| 69 | |
| 70 return false; | |
| 71 } | |
| 72 | |
| 73 NSDictionary* GetMIMETypes(CFBundleRef bundle) { | |
| 74 NSString* mime_filename = | |
| 75 (NSString*)CFBundleGetValueForInfoDictionaryKey(bundle, | |
| 76 CFSTR("WebPluginMIMETypesFilename")); | |
| 77 | |
| 78 if (mime_filename) { | |
| 79 | |
| 80 // get the file | |
| 81 | |
| 82 NSString* mime_path = | |
| 83 [NSString stringWithFormat:@"%@/Library/Preferences/%@", | |
| 84 NSHomeDirectory(), mime_filename]; | |
| 85 NSDictionary* mime_file_dict = | |
| 86 [NSDictionary dictionaryWithContentsOfFile:mime_path]; | |
| 87 | |
| 88 // is it valid? | |
| 89 | |
| 90 bool valid_file = false; | |
| 91 if (mime_file_dict) { | |
| 92 NSString* l10n_name = | |
| 93 [mime_file_dict objectForKey:@"WebPluginLocalizationName"]; | |
| 94 NSString* preferred_l10n = [[NSLocale currentLocale] localeIdentifier]; | |
| 95 if ([l10n_name isEqualToString:preferred_l10n]) | |
| 96 valid_file = true; | |
| 97 } | |
| 98 | |
| 99 if (valid_file) | |
| 100 return [mime_file_dict objectForKey:@"WebPluginMIMETypes"]; | |
| 101 | |
| 102 // dammit, I didn't want to have to do this | |
| 103 | |
| 104 typedef void (*CreateMIMETypesPrefsPtr)(void); | |
| 105 CreateMIMETypesPrefsPtr create_prefs_file = | |
| 106 (CreateMIMETypesPrefsPtr)CFBundleGetFunctionPointerForName( | |
| 107 bundle, CFSTR("BP_CreatePluginMIMETypesPreferences")); | |
| 108 if (!create_prefs_file) | |
| 109 return nil; | |
| 110 create_prefs_file(); | |
| 111 | |
| 112 // one more time | |
| 113 | |
| 114 mime_file_dict = [NSDictionary dictionaryWithContentsOfFile:mime_path]; | |
| 115 if (mime_file_dict) | |
| 116 return [mime_file_dict objectForKey:@"WebPluginMIMETypes"]; | |
| 117 else | |
| 118 return nil; | |
| 119 | |
| 120 } else { | |
| 121 return (NSDictionary*)CFBundleGetValueForInfoDictionaryKey(bundle, | |
| 122 CFSTR("WebPluginMIMETypes")); | |
| 123 } | |
| 124 } | |
| 125 | |
| 126 bool ReadPlistPluginInfo(const base::FilePath& filename, CFBundleRef bundle, | |
| 127 WebPluginInfo* info) { | |
| 128 NSDictionary* mime_types = GetMIMETypes(bundle); | |
| 129 if (!mime_types) | |
| 130 return false; // no type info here; try elsewhere | |
| 131 | |
| 132 for (NSString* mime_type in [mime_types allKeys]) { | |
| 133 NSDictionary* mime_dict = [mime_types objectForKey:mime_type]; | |
| 134 NSNumber* type_enabled = [mime_dict objectForKey:@"WebPluginTypeEnabled"]; | |
| 135 NSString* mime_desc = [mime_dict objectForKey:@"WebPluginTypeDescription"]; | |
| 136 NSArray* mime_exts = [mime_dict objectForKey:@"WebPluginExtensions"]; | |
| 137 | |
| 138 // Skip any disabled types. | |
| 139 if (type_enabled && ![type_enabled boolValue]) | |
| 140 continue; | |
| 141 | |
| 142 WebPluginMimeType mime; | |
| 143 mime.mime_type = base::SysNSStringToUTF8([mime_type lowercaseString]); | |
| 144 // Remove PDF from the list of types handled by QuickTime, since it provides | |
| 145 // a worse experience than just downloading the PDF. | |
| 146 if (mime.mime_type == "application/pdf" && | |
| 147 StartsWithASCII(filename.BaseName().value(), "QuickTime", false)) { | |
| 148 continue; | |
| 149 } | |
| 150 | |
| 151 if (mime_desc) | |
| 152 mime.description = base::SysNSStringToUTF16(mime_desc); | |
| 153 for (NSString* ext in mime_exts) | |
| 154 mime.file_extensions.push_back( | |
| 155 base::SysNSStringToUTF8([ext lowercaseString])); | |
| 156 | |
| 157 info->mime_types.push_back(mime); | |
| 158 } | |
| 159 | |
| 160 NSString* plugin_name = | |
| 161 (NSString*)CFBundleGetValueForInfoDictionaryKey(bundle, | |
| 162 CFSTR("WebPluginName")); | |
| 163 NSString* plugin_vers = | |
| 164 (NSString*)CFBundleGetValueForInfoDictionaryKey(bundle, | |
| 165 CFSTR("CFBundleShortVersionString")); | |
| 166 NSString* plugin_desc = | |
| 167 (NSString*)CFBundleGetValueForInfoDictionaryKey(bundle, | |
| 168 CFSTR("WebPluginDescription")); | |
| 169 | |
| 170 if (plugin_name) | |
| 171 info->name = base::SysNSStringToUTF16(plugin_name); | |
| 172 else | |
| 173 info->name = UTF8ToUTF16(filename.BaseName().value()); | |
| 174 info->path = filename; | |
| 175 if (plugin_vers) | |
| 176 info->version = base::SysNSStringToUTF16(plugin_vers); | |
| 177 if (plugin_desc) | |
| 178 info->desc = base::SysNSStringToUTF16(plugin_desc); | |
| 179 else | |
| 180 info->desc = UTF8ToUTF16(filename.BaseName().value()); | |
| 181 | |
| 182 return true; | |
| 183 } | |
| 184 | |
| 185 } // namespace | |
| 186 | |
| 187 bool PluginList::ReadWebPluginInfo(const base::FilePath &filename, | |
| 188 WebPluginInfo* info) { | |
| 189 // There are three ways to get information about plugin capabilities: | |
| 190 // 1) a set of Info.plist keys, documented at | |
| 191 // http://developer.apple.com/documentation/InternetWeb/Conceptual/WebKit_Plug
inProgTopic/Concepts/AboutPlugins.html . | |
| 192 // 2) a set of STR# resources, documented at | |
| 193 // https://developer.mozilla.org/En/Gecko_Plugin_API_Reference/Plug-in_Develop
ment_Overview . | |
| 194 // 3) a NP_GetMIMEDescription() entry point, documented at | |
| 195 // https://developer.mozilla.org/en/NP_GetMIMEDescription | |
| 196 // | |
| 197 // Mozilla supported (3), but WebKit never has, so no plugins rely on it. Most | |
| 198 // browsers supported (2) and then added support for (1); Chromium originally | |
| 199 // supported (2) and (1), but now supports only (1) as (2) is deprecated. | |
| 200 // | |
| 201 // For the Info.plist version, the data is formatted as follows (in text plist | |
| 202 // format): | |
| 203 // { | |
| 204 // ... the usual plist keys ... | |
| 205 // WebPluginDescription = <<plugindescription>>; | |
| 206 // WebPluginMIMETypes = { | |
| 207 // <<type0mimetype>> = { | |
| 208 // WebPluginExtensions = ( | |
| 209 // <<type0fileextension0>>, | |
| 210 // ... | |
| 211 // <<type0fileextensionk>>, | |
| 212 // ); | |
| 213 // WebPluginTypeDescription = <<type0description>>; | |
| 214 // }; | |
| 215 // <<type1mimetype>> = { ... }; | |
| 216 // ... | |
| 217 // <<typenmimetype>> = { ... }; | |
| 218 // }; | |
| 219 // WebPluginName = <<pluginname>>; | |
| 220 // } | |
| 221 // | |
| 222 // Alternatively (and this is undocumented), rather than a WebPluginMIMETypes | |
| 223 // key, there may be a WebPluginMIMETypesFilename key. If it is present, then | |
| 224 // it is the name of a file in the user's preferences folder in which to find | |
| 225 // the WebPluginMIMETypes key. If the key is present but the file doesn't | |
| 226 // exist, we must load the plugin and call a specific function to have the | |
| 227 // plugin create the file. | |
| 228 | |
| 229 ScopedCFTypeRef<CFURLRef> bundle_url(CFURLCreateFromFileSystemRepresentation( | |
| 230 kCFAllocatorDefault, (const UInt8*)filename.value().c_str(), | |
| 231 filename.value().length(), true)); | |
| 232 if (!bundle_url) { | |
| 233 LOG_IF(ERROR, PluginList::DebugPluginLoading()) | |
| 234 << "PluginLib::ReadWebPluginInfo could not create bundle URL"; | |
| 235 return false; | |
| 236 } | |
| 237 ScopedCFTypeRef<CFBundleRef> bundle(CFBundleCreate(kCFAllocatorDefault, | |
| 238 bundle_url.get())); | |
| 239 if (!bundle) { | |
| 240 LOG_IF(ERROR, PluginList::DebugPluginLoading()) | |
| 241 << "PluginLib::ReadWebPluginInfo could not create CFBundleRef"; | |
| 242 return false; | |
| 243 } | |
| 244 | |
| 245 // preflight | |
| 246 | |
| 247 OSType type = 0; | |
| 248 CFBundleGetPackageInfo(bundle.get(), &type, NULL); | |
| 249 if (type != FOUR_CHAR_CODE('BRPL')) { | |
| 250 LOG_IF(ERROR, PluginList::DebugPluginLoading()) | |
| 251 << "PluginLib::ReadWebPluginInfo bundle is not BRPL, is " << type; | |
| 252 return false; | |
| 253 } | |
| 254 | |
| 255 CFErrorRef error; | |
| 256 Boolean would_load = CFBundlePreflightExecutable(bundle.get(), &error); | |
| 257 if (!would_load) { | |
| 258 ScopedCFTypeRef<CFStringRef> error_string(CFErrorCopyDescription(error)); | |
| 259 LOG_IF(ERROR, PluginList::DebugPluginLoading()) | |
| 260 << "PluginLib::ReadWebPluginInfo bundle failed preflight: " | |
| 261 << base::SysCFStringRefToUTF8(error_string); | |
| 262 return false; | |
| 263 } | |
| 264 | |
| 265 // get the info | |
| 266 | |
| 267 if (ReadPlistPluginInfo(filename, bundle.get(), info)) | |
| 268 return true; | |
| 269 | |
| 270 // ... or not | |
| 271 | |
| 272 return false; | |
| 273 } | |
| 274 | |
| 275 void PluginList::GetPluginDirectories( | |
| 276 std::vector<base::FilePath>* plugin_dirs) { | |
| 277 if (PluginList::plugins_discovery_disabled_) | |
| 278 return; | |
| 279 | |
| 280 // Load from the user's area | |
| 281 GetPluginCommonDirectory(plugin_dirs, true); | |
| 282 | |
| 283 // Load from the machine-wide area | |
| 284 GetPluginCommonDirectory(plugin_dirs, false); | |
| 285 } | |
| 286 | |
| 287 void PluginList::GetPluginsInDir( | |
| 288 const base::FilePath& path, std::vector<base::FilePath>* plugins) { | |
| 289 base::FileEnumerator enumerator(path, | |
| 290 false, // not recursive | |
| 291 base::FileEnumerator::DIRECTORIES); | |
| 292 for (base::FilePath path = enumerator.Next(); !path.value().empty(); | |
| 293 path = enumerator.Next()) { | |
| 294 plugins->push_back(path); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 bool PluginList::ShouldLoadPluginUsingPluginList( | |
| 299 const WebPluginInfo& info, | |
| 300 std::vector<webkit::WebPluginInfo>* plugins) { | |
| 301 return !IsBlacklistedPlugin(info); | |
| 302 } | |
| 303 | |
| 304 } // namespace npapi | |
| 305 } // namespace webkit | |
| 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/