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 "chrome/common/chrome_content_client.h" 6 7 #include "base/command_line.h" 8 #include "base/cpu.h" 9 #include "base/file_util.h" 10 #include "base/path_service.h" 11 #include "base/strings/string_number_conversions.h" 12 #include "base/strings/string_split.h" 13 #include "base/strings/string_util.h" 14 #include "base/strings/stringprintf.h" 15 #include "base/strings/utf_string_conversions.h" 16 #include "build/build_config.h" 17 #include "chrome/common/child_process_logging.h" 18 #include "chrome/common/chrome_paths.h" 19 #include "chrome/common/chrome_switches.h" 20 #include "chrome/common/chrome_version_info.h" 21 #include "chrome/common/pepper_flash.h" 22 #include "chrome/common/render_messages.h" 23 #include "chrome/common/url_constants.h" 24 #include "components/nacl/common/nacl_process_type.h" 25 #include "content/public/common/content_constants.h" 26 #include "content/public/common/content_switches.h" 27 #include "content/public/common/pepper_plugin_info.h" 28 #include "content/public/common/url_constants.h" 29 #include "extensions/common/constants.h" 30 #include "grit/common_resources.h" 31 #include "ppapi/shared_impl/ppapi_permissions.h" 32 #include "remoting/client/plugin/pepper_entrypoints.h" 33 #include "ui/base/l10n/l10n_util.h" 34 #include "ui/base/layout.h" 35 #include "ui/base/resource/resource_bundle.h" 36 #include "webkit/common/user_agent/user_agent_util.h" 37 38 #include "flapper_version.h" // In SHARED_INTERMEDIATE_DIR. 39 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. 40 41 #if defined(OS_WIN) 42 #include "base/win/registry.h" 43 #include "base/win/windows_version.h" 44 #include "sandbox/win/src/sandbox.h" 45 #elif defined(OS_MACOSX) 46 #include "components/nacl/common/nacl_sandbox_type_mac.h" 47 #endif 48 49 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \ 50 !defined(WIDEVINE_CDM_IS_COMPONENT) 51 #include "chrome/common/widevine_cdm_constants.h" 52 #endif 53 54 namespace { 55 56 const char kPDFPluginMimeType[] = "application/pdf"; 57 const char kPDFPluginExtension[] = "pdf"; 58 const char kPDFPluginDescription[] = "Portable Document Format"; 59 const char kPDFPluginPrintPreviewMimeType 60 [] = "application/x-google-chrome-print-preview-pdf"; 61 const uint32 kPDFPluginPermissions = ppapi::PERMISSION_PRIVATE | 62 ppapi::PERMISSION_DEV; 63 64 const char kNaClPluginMimeType[] = "application/x-nacl"; 65 const char kNaClPluginExtension[] = ""; 66 const char kNaClPluginDescription[] = "Native Client Executable"; 67 const uint32 kNaClPluginPermissions = ppapi::PERMISSION_PRIVATE | 68 ppapi::PERMISSION_DEV; 69 70 const char kPnaclPluginMimeType[] = "application/x-pnacl"; 71 const char kPnaclPluginExtension[] = ""; 72 const char kPnaclPluginDescription[] = "Portable Native Client Executable"; 73 const uint32 kPnaclPluginPermissions = ppapi::PERMISSION_PRIVATE | 74 ppapi::PERMISSION_DEV; 75 76 const char kO3DPluginName[] = "Google Talk Plugin Video Accelerator"; 77 const char kO3DPluginMimeType[] ="application/vnd.o3d.auto"; 78 const char kO3DPluginExtension[] = ""; 79 const char kO3DPluginDescription[] = "O3D MIME"; 80 const uint32 kO3DPluginPermissions = ppapi::PERMISSION_PRIVATE | 81 ppapi::PERMISSION_DEV; 82 83 const char kO1DPluginName[] = "Google Talk Plugin Video Renderer"; 84 const char kO1DPluginMimeType[] ="application/o1d"; 85 const char kO1DPluginExtension[] = ""; 86 const char kO1DPluginDescription[] = "Google Talk Plugin Video Renderer"; 87 const uint32 kO1DPluginPermissions = ppapi::PERMISSION_PRIVATE | 88 ppapi::PERMISSION_DEV; 89 90 const char kGTalkPluginName[] = "Google Talk Plugin"; 91 const char kGTalkPluginMimeType[] ="application/googletalk"; 92 const char kGTalkPluginExtension[] = ".googletalk"; 93 const char kGTalkPluginDescription[] = "Google Talk Plugin"; 94 const uint32 kGTalkPluginPermissions = ppapi::PERMISSION_PRIVATE | 95 ppapi::PERMISSION_DEV; 96 97 #if defined(ENABLE_REMOTING) 98 #if defined(GOOGLE_CHROME_BUILD) 99 const char kRemotingViewerPluginName[] = "Chrome Remote Desktop Viewer"; 100 #else 101 const char kRemotingViewerPluginName[] = "Chromoting Viewer"; 102 #endif // defined(GOOGLE_CHROME_BUILD) 103 const char kRemotingViewerPluginDescription[] = 104 "This plugin allows you to securely access other computers that have been " 105 "shared with you. To use this plugin you must first install the " 106 "<a href=\"https://chrome.google.com/remotedesktop\">" 107 "Chrome Remote Desktop</a> webapp."; 108 const base::FilePath::CharType kRemotingViewerPluginPath[] = 109 FILE_PATH_LITERAL("internal-remoting-viewer"); 110 // Use a consistent MIME-type regardless of branding. 111 const char kRemotingViewerPluginMimeType[] = 112 "application/vnd.chromium.remoting-viewer"; 113 const char kRemotingViewerPluginMimeExtension[] = ""; 114 const char kRemotingViewerPluginMimeDescription[] = ""; 115 const uint32 kRemotingViewerPluginPermissions = ppapi::PERMISSION_PRIVATE | 116 ppapi::PERMISSION_DEV; 117 #endif // defined(ENABLE_REMOTING) 118 119 const char kInterposeLibraryPath[] = 120 "@executable_path/../../../libplugin_carbon_interpose.dylib"; 121 122 // Appends the known built-in plugins to the given vector. Some built-in 123 // plugins are "internal" which means they are compiled into the Chrome binary, 124 // and some are extra shared libraries distributed with the browser (these are 125 // not marked internal, aside from being automatically registered, they're just 126 // regular plugins). 127 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) { 128 // PDF. 129 // 130 // Once we're sandboxed, we can't know if the PDF plugin is available or not; 131 // but (on Linux) this function is always called once before we're sandboxed. 132 // So the first time through test if the file is available and then skip the 133 // check on subsequent calls if yes. 134 static bool skip_pdf_file_check = false; 135 base::FilePath path; 136 if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) { 137 if (skip_pdf_file_check || base::PathExists(path)) { 138 content::PepperPluginInfo pdf; 139 pdf.path = path; 140 pdf.name = chrome::ChromeContentClient::kPDFPluginName; 141 content::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType, 142 kPDFPluginExtension, 143 kPDFPluginDescription); 144 content::WebPluginMimeType print_preview_pdf_mime_type( 145 kPDFPluginPrintPreviewMimeType, 146 kPDFPluginExtension, 147 kPDFPluginDescription); 148 pdf.mime_types.push_back(pdf_mime_type); 149 pdf.mime_types.push_back(print_preview_pdf_mime_type); 150 pdf.permissions = kPDFPluginPermissions; 151 plugins->push_back(pdf); 152 153 skip_pdf_file_check = true; 154 } 155 } 156 157 // Handle Native Client just like the PDF plugin. This means that it is 158 // enabled by default for the non-portable case. This allows apps installed 159 // from the Chrome Web Store to use NaCl even if the command line switch 160 // isn't set. For other uses of NaCl we check for the command line switch. 161 // Specifically, Portable Native Client is only enabled by the command line 162 // switch. 163 static bool skip_nacl_file_check = false; 164 if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) { 165 if (skip_nacl_file_check || base::PathExists(path)) { 166 content::PepperPluginInfo nacl; 167 nacl.path = path; 168 nacl.name = chrome::ChromeContentClient::kNaClPluginName; 169 content::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType, 170 kNaClPluginExtension, 171 kNaClPluginDescription); 172 nacl.mime_types.push_back(nacl_mime_type); 173 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePnacl)) { 174 content::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType, 175 kPnaclPluginExtension, 176 kPnaclPluginDescription); 177 nacl.mime_types.push_back(pnacl_mime_type); 178 } 179 nacl.permissions = kNaClPluginPermissions; 180 plugins->push_back(nacl); 181 182 skip_nacl_file_check = true; 183 } 184 } 185 186 // TODO(jhorwich|noahric): Remove o3d ppapi code once o3d is replaced 187 // entirely with o1d. 188 static bool skip_o3d_file_check = false; 189 if (PathService::Get(chrome::FILE_O3D_PLUGIN, &path)) { 190 if (skip_o3d_file_check || base::PathExists(path)) { 191 content::PepperPluginInfo o3d; 192 o3d.path = path; 193 o3d.name = kO3DPluginName; 194 o3d.is_out_of_process = true; 195 o3d.is_sandboxed = false; 196 o3d.permissions = kO3DPluginPermissions; 197 content::WebPluginMimeType o3d_mime_type(kO3DPluginMimeType, 198 kO3DPluginExtension, 199 kO3DPluginDescription); 200 o3d.mime_types.push_back(o3d_mime_type); 201 plugins->push_back(o3d); 202 203 skip_o3d_file_check = true; 204 } 205 } 206 207 static bool skip_o1d_file_check = false; 208 if (PathService::Get(chrome::FILE_O1D_PLUGIN, &path)) { 209 if (skip_o1d_file_check || base::PathExists(path)) { 210 content::PepperPluginInfo o1d; 211 o1d.path = path; 212 o1d.name = kO1DPluginName; 213 o1d.is_out_of_process = true; 214 o1d.is_sandboxed = false; 215 o1d.permissions = kO1DPluginPermissions; 216 content::WebPluginMimeType o1d_mime_type(kO1DPluginMimeType, 217 kO1DPluginExtension, 218 kO1DPluginDescription); 219 o1d.mime_types.push_back(o1d_mime_type); 220 plugins->push_back(o1d); 221 222 skip_o1d_file_check = true; 223 } 224 } 225 226 static bool skip_gtalk_file_check = false; 227 if (PathService::Get(chrome::FILE_GTALK_PLUGIN, &path)) { 228 if (skip_gtalk_file_check || base::PathExists(path)) { 229 content::PepperPluginInfo gtalk; 230 gtalk.path = path; 231 gtalk.name = kGTalkPluginName; 232 gtalk.is_out_of_process = true; 233 gtalk.is_sandboxed = false; 234 gtalk.permissions = kGTalkPluginPermissions; 235 content::WebPluginMimeType gtalk_mime_type(kGTalkPluginMimeType, 236 kGTalkPluginExtension, 237 kGTalkPluginDescription); 238 gtalk.mime_types.push_back(gtalk_mime_type); 239 plugins->push_back(gtalk); 240 241 skip_gtalk_file_check = true; 242 } 243 } 244 245 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \ 246 !defined(WIDEVINE_CDM_IS_COMPONENT) 247 static bool skip_widevine_cdm_file_check = false; 248 if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &path)) { 249 if (skip_widevine_cdm_file_check || base::PathExists(path)) { 250 content::PepperPluginInfo widevine_cdm; 251 widevine_cdm.is_out_of_process = true; 252 widevine_cdm.path = path; 253 widevine_cdm.name = kWidevineCdmDisplayName; 254 widevine_cdm.description = kWidevineCdmDescription; 255 widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING; 256 content::WebPluginMimeType widevine_cdm_mime_type( 257 kWidevineCdmPluginMimeType, 258 kWidevineCdmPluginExtension, 259 kWidevineCdmPluginMimeTypeDescription); 260 widevine_cdm.mime_types.push_back(widevine_cdm_mime_type); 261 widevine_cdm.permissions = kWidevineCdmPluginPermissions; 262 plugins->push_back(widevine_cdm); 263 264 skip_widevine_cdm_file_check = true; 265 } 266 } 267 #endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && 268 // !defined(WIDEVINE_CDM_IS_COMPONENT) 269 270 // The Remoting Viewer plugin is built-in. 271 #if defined(ENABLE_REMOTING) 272 content::PepperPluginInfo info; 273 info.is_internal = true; 274 info.is_out_of_process = true; 275 info.name = kRemotingViewerPluginName; 276 info.description = kRemotingViewerPluginDescription; 277 info.path = base::FilePath(kRemotingViewerPluginPath); 278 content::WebPluginMimeType remoting_mime_type( 279 kRemotingViewerPluginMimeType, 280 kRemotingViewerPluginMimeExtension, 281 kRemotingViewerPluginMimeDescription); 282 info.mime_types.push_back(remoting_mime_type); 283 info.internal_entry_points.get_interface = remoting::PPP_GetInterface; 284 info.internal_entry_points.initialize_module = 285 remoting::PPP_InitializeModule; 286 info.internal_entry_points.shutdown_module = remoting::PPP_ShutdownModule; 287 info.permissions = kRemotingViewerPluginPermissions; 288 289 plugins->push_back(info); 290 #endif 291 } 292 293 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path, 294 const std::string& version) { 295 content::PepperPluginInfo plugin; 296 297 // Flash being out of process is handled separately than general plugins 298 // for testing purposes. 299 plugin.is_out_of_process = !CommandLine::ForCurrentProcess()->HasSwitch( 300 switches::kPpapiFlashInProcess); 301 plugin.name = content::kFlashPluginName; 302 plugin.path = path; 303 plugin.permissions = kPepperFlashPermissions; 304 305 std::vector<std::string> flash_version_numbers; 306 base::SplitString(version, '.', &flash_version_numbers); 307 if (flash_version_numbers.size() < 1) 308 flash_version_numbers.push_back("11"); 309 // |SplitString()| puts in an empty string given an empty string. :( 310 else if (flash_version_numbers[0].empty()) 311 flash_version_numbers[0] = "11"; 312 if (flash_version_numbers.size() < 2) 313 flash_version_numbers.push_back("2"); 314 if (flash_version_numbers.size() < 3) 315 flash_version_numbers.push_back("999"); 316 if (flash_version_numbers.size() < 4) 317 flash_version_numbers.push_back("999"); 318 // E.g., "Shockwave Flash 10.2 r154": 319 plugin.description = plugin.name + " " + flash_version_numbers[0] + "." + 320 flash_version_numbers[1] + " r" + flash_version_numbers[2]; 321 plugin.version = JoinString(flash_version_numbers, '.'); 322 content::WebPluginMimeType swf_mime_type(content::kFlashPluginSwfMimeType, 323 content::kFlashPluginSwfExtension, 324 content::kFlashPluginSwfDescription); 325 plugin.mime_types.push_back(swf_mime_type); 326 content::WebPluginMimeType spl_mime_type(content::kFlashPluginSplMimeType, 327 content::kFlashPluginSplExtension, 328 content::kFlashPluginSplDescription); 329 plugin.mime_types.push_back(spl_mime_type); 330 331 return plugin; 332 } 333 334 void AddPepperFlashFromCommandLine( 335 std::vector<content::PepperPluginInfo>* plugins) { 336 const CommandLine::StringType flash_path = 337 CommandLine::ForCurrentProcess()->GetSwitchValueNative( 338 switches::kPpapiFlashPath); 339 if (flash_path.empty()) 340 return; 341 342 // Also get the version from the command-line. Should be something like 11.2 343 // or 11.2.123.45. 344 std::string flash_version = 345 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 346 switches::kPpapiFlashVersion); 347 348 plugins->push_back( 349 CreatePepperFlashInfo(base::FilePath(flash_path), flash_version)); 350 } 351 352 bool GetBundledPepperFlash(content::PepperPluginInfo* plugin) { 353 #if defined(FLAPPER_AVAILABLE) 354 CommandLine* command_line = CommandLine::ForCurrentProcess(); 355 356 // Ignore bundled Pepper Flash if there is Pepper Flash specified from the 357 // command-line. 358 if (command_line->HasSwitch(switches::kPpapiFlashPath)) 359 return false; 360 361 bool force_disable = 362 command_line->HasSwitch(switches::kDisableBundledPpapiFlash); 363 if (force_disable) 364 return false; 365 366 // For Linux ia32, Flapper requires SSE2. 367 #if defined(OS_LINUX) && defined(ARCH_CPU_X86) 368 if (!base::CPU().has_sse2()) 369 return false; 370 #endif // ARCH_CPU_X86 371 372 base::FilePath flash_path; 373 if (!PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &flash_path)) 374 return false; 375 376 *plugin = CreatePepperFlashInfo(flash_path, FLAPPER_VERSION_STRING); 377 return true; 378 #else 379 return false; 380 #endif // FLAPPER_AVAILABLE 381 } 382 383 } // namespace 384 385 namespace chrome { 386 387 void ChromeContentClient::SetActiveURL(const GURL& url) { 388 child_process_logging::SetActiveURL(url); 389 } 390 391 void ChromeContentClient::SetGpuInfo(const gpu::GPUInfo& gpu_info) { 392 child_process_logging::SetGpuInfo(gpu_info); 393 } 394 395 void ChromeContentClient::AddPepperPlugins( 396 std::vector<content::PepperPluginInfo>* plugins) { 397 ComputeBuiltInPlugins(plugins); 398 AddPepperFlashFromCommandLine(plugins); 399 400 content::PepperPluginInfo plugin; 401 if (GetBundledPepperFlash(&plugin)) 402 plugins->push_back(plugin); 403 } 404 405 void ChromeContentClient::AddAdditionalSchemes( 406 std::vector<std::string>* standard_schemes, 407 std::vector<std::string>* savable_schemes) { 408 standard_schemes->push_back(extensions::kExtensionScheme); 409 savable_schemes->push_back(extensions::kExtensionScheme); 410 standard_schemes->push_back(kExtensionResourceScheme); 411 savable_schemes->push_back(kExtensionResourceScheme); 412 standard_schemes->push_back(chrome::kChromeSearchScheme); 413 savable_schemes->push_back(chrome::kChromeSearchScheme); 414 #if defined(OS_CHROMEOS) 415 standard_schemes->push_back(kCrosScheme); 416 #endif 417 } 418 419 bool ChromeContentClient::CanHandleWhileSwappedOut( 420 const IPC::Message& msg) { 421 // Any Chrome-specific messages (apart from those listed in 422 // CanSendWhileSwappedOut) that must be handled by the browser when sent from 423 // swapped out renderers. 424 return false; 425 } 426 427 std::string ChromeContentClient::GetProduct() const { 428 chrome::VersionInfo version_info; 429 return version_info.is_valid() ? 430 version_info.ProductNameAndVersionForUserAgent() : std::string(); 431 } 432 433 std::string ChromeContentClient::GetUserAgent() const { 434 std::string product = GetProduct(); 435 #if defined(OS_ANDROID) 436 CommandLine* command_line = CommandLine::ForCurrentProcess(); 437 if (command_line->HasSwitch(switches::kUseMobileUserAgent)) 438 product += " Mobile"; 439 #endif 440 return webkit_glue::BuildUserAgentFromProduct(product); 441 } 442 443 string16 ChromeContentClient::GetLocalizedString(int message_id) const { 444 return l10n_util::GetStringUTF16(message_id); 445 } 446 447 base::StringPiece ChromeContentClient::GetDataResource( 448 int resource_id, 449 ui::ScaleFactor scale_factor) const { 450 return ResourceBundle::GetSharedInstance().GetRawDataResourceForScale( 451 resource_id, scale_factor); 452 } 453 454 base::RefCountedStaticMemory* ChromeContentClient::GetDataResourceBytes( 455 int resource_id) const { 456 return ResourceBundle::GetSharedInstance().LoadDataResourceBytes(resource_id); 457 } 458 459 gfx::Image& ChromeContentClient::GetNativeImageNamed(int resource_id) const { 460 return ResourceBundle::GetSharedInstance().GetNativeImageNamed(resource_id); 461 } 462 463 std::string ChromeContentClient::GetProcessTypeNameInEnglish(int type) { 464 switch (type) { 465 case PROCESS_TYPE_NACL_LOADER: 466 return "Native Client module"; 467 case PROCESS_TYPE_NACL_BROKER: 468 return "Native Client broker"; 469 } 470 471 DCHECK(false) << "Unknown child process type!"; 472 return "Unknown"; 473 } 474 475 #if defined(OS_MACOSX) && !defined(OS_IOS) 476 bool ChromeContentClient::GetSandboxProfileForSandboxType( 477 int sandbox_type, 478 int* sandbox_profile_resource_id) const { 479 DCHECK(sandbox_profile_resource_id); 480 if (sandbox_type == NACL_SANDBOX_TYPE_NACL_LOADER) { 481 *sandbox_profile_resource_id = IDR_NACL_SANDBOX_PROFILE; 482 return true; 483 } 484 return false; 485 } 486 487 std::string ChromeContentClient::GetCarbonInterposePath() const { 488 return std::string(kInterposeLibraryPath); 489 } 490 #endif 491 492 } // namespace chrome 493