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 "content/browser/plugin_service_impl.h" 6 7 #include "base/bind.h" 8 #include "base/command_line.h" 9 #include "base/compiler_specific.h" 10 #include "base/files/file_path.h" 11 #include "base/message_loop/message_loop.h" 12 #include "base/message_loop/message_loop_proxy.h" 13 #include "base/metrics/histogram.h" 14 #include "base/path_service.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "base/synchronization/waitable_event.h" 18 #include "base/threading/thread.h" 19 #include "content/browser/ppapi_plugin_process_host.h" 20 #include "content/browser/renderer_host/render_process_host_impl.h" 21 #include "content/browser/renderer_host/render_view_host_impl.h" 22 #include "content/common/pepper_plugin_list.h" 23 #include "content/common/plugin_list.h" 24 #include "content/common/view_messages.h" 25 #include "content/public/browser/browser_thread.h" 26 #include "content/public/browser/content_browser_client.h" 27 #include "content/public/browser/plugin_service_filter.h" 28 #include "content/public/browser/resource_context.h" 29 #include "content/public/common/content_constants.h" 30 #include "content/public/common/content_switches.h" 31 #include "content/public/common/process_type.h" 32 #include "content/public/common/webplugininfo.h" 33 34 #if defined(OS_WIN) 35 #include "content/common/plugin_constants_win.h" 36 #include "ui/gfx/win/hwnd_util.h" 37 #endif 38 39 #if defined(OS_POSIX) 40 #include "content/browser/plugin_loader_posix.h" 41 #endif 42 43 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID) 44 using ::base::FilePathWatcher; 45 #endif 46 47 namespace content { 48 namespace { 49 50 // This enum is used to collect Flash usage data. 51 enum FlashUsage { 52 // Number of browser processes that have started at least one NPAPI Flash 53 // process during their lifetime. 54 START_NPAPI_FLASH_AT_LEAST_ONCE, 55 // Number of browser processes that have started at least one PPAPI Flash 56 // process during their lifetime. 57 START_PPAPI_FLASH_AT_LEAST_ONCE, 58 // Total number of browser processes. 59 TOTAL_BROWSER_PROCESSES, 60 FLASH_USAGE_ENUM_COUNT 61 }; 62 63 bool LoadPluginListInProcess() { 64 #if defined(OS_WIN) 65 return true; 66 #else 67 // If on POSIX, we don't want to load the list of NPAPI plugins in-process as 68 // that causes instability. 69 70 // Can't load the plugins on the utility thread when in single process mode 71 // since that requires GTK which can only be used on the main thread. 72 if (RenderProcessHost::run_renderer_in_process()) 73 return true; 74 75 return !PluginService::GetInstance()->NPAPIPluginsSupported(); 76 #endif 77 } 78 79 // Callback set on the PluginList to assert that plugin loading happens on the 80 // correct thread. 81 void WillLoadPluginsCallback( 82 base::SequencedWorkerPool::SequenceToken token) { 83 if (LoadPluginListInProcess()) { 84 CHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread( 85 token)); 86 } else { 87 CHECK(false) << "Plugin loading should happen out-of-process."; 88 } 89 } 90 91 #if defined(OS_MACOSX) 92 void NotifyPluginsOfActivation() { 93 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 94 95 for (PluginProcessHostIterator iter; !iter.Done(); ++iter) 96 iter->OnAppActivation(); 97 } 98 #endif 99 100 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID) 101 void NotifyPluginDirChanged(const base::FilePath& path, bool error) { 102 if (error) { 103 // TODO(pastarmovj): Add some sensible error handling. Maybe silently 104 // stopping the watcher would be enough. Or possibly restart it. 105 NOTREACHED(); 106 return; 107 } 108 VLOG(1) << "Watched path changed: " << path.value(); 109 // Make the plugin list update itself 110 PluginList::Singleton()->RefreshPlugins(); 111 BrowserThread::PostTask( 112 BrowserThread::UI, FROM_HERE, 113 base::Bind(&PluginService::PurgePluginListCache, 114 static_cast<BrowserContext*>(NULL), false)); 115 } 116 #endif 117 118 void ForwardCallback(base::MessageLoopProxy* target_loop, 119 const PluginService::GetPluginsCallback& callback, 120 const std::vector<WebPluginInfo>& plugins) { 121 target_loop->PostTask(FROM_HERE, base::Bind(callback, plugins)); 122 } 123 124 } // namespace 125 126 // static 127 PluginService* PluginService::GetInstance() { 128 return PluginServiceImpl::GetInstance(); 129 } 130 131 void PluginService::PurgePluginListCache(BrowserContext* browser_context, 132 bool reload_pages) { 133 for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator(); 134 !it.IsAtEnd(); it.Advance()) { 135 RenderProcessHost* host = it.GetCurrentValue(); 136 if (!browser_context || host->GetBrowserContext() == browser_context) 137 host->Send(new ViewMsg_PurgePluginListCache(reload_pages)); 138 } 139 } 140 141 // static 142 PluginServiceImpl* PluginServiceImpl::GetInstance() { 143 return Singleton<PluginServiceImpl>::get(); 144 } 145 146 PluginServiceImpl::PluginServiceImpl() 147 : filter_(NULL) { 148 // Collect the total number of browser processes (which create 149 // PluginServiceImpl objects, to be precise). The number is used to normalize 150 // the number of processes which start at least one NPAPI/PPAPI Flash process. 151 static bool counted = false; 152 if (!counted) { 153 counted = true; 154 UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage", TOTAL_BROWSER_PROCESSES, 155 FLASH_USAGE_ENUM_COUNT); 156 } 157 } 158 159 PluginServiceImpl::~PluginServiceImpl() { 160 #if defined(OS_WIN) 161 // Release the events since they're owned by RegKey, not WaitableEvent. 162 hkcu_watcher_.StopWatching(); 163 hklm_watcher_.StopWatching(); 164 if (hkcu_event_) 165 hkcu_event_->Release(); 166 if (hklm_event_) 167 hklm_event_->Release(); 168 #endif 169 // Make sure no plugin channel requests have been leaked. 170 DCHECK(pending_plugin_clients_.empty()); 171 } 172 173 void PluginServiceImpl::Init() { 174 plugin_list_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken(); 175 PluginList::Singleton()->set_will_load_plugins_callback( 176 base::Bind(&WillLoadPluginsCallback, plugin_list_token_)); 177 178 RegisterPepperPlugins(); 179 180 // Load any specified on the command line as well. 181 const CommandLine* command_line = CommandLine::ForCurrentProcess(); 182 base::FilePath path = 183 command_line->GetSwitchValuePath(switches::kLoadPlugin); 184 if (!path.empty()) 185 AddExtraPluginPath(path); 186 path = command_line->GetSwitchValuePath(switches::kExtraPluginDir); 187 if (!path.empty()) 188 PluginList::Singleton()->AddExtraPluginDir(path); 189 190 if (command_line->HasSwitch(switches::kDisablePluginsDiscovery)) 191 PluginList::Singleton()->DisablePluginsDiscovery(); 192 } 193 194 void PluginServiceImpl::StartWatchingPlugins() { 195 // Start watching for changes in the plugin list. This means watching 196 // for changes in the Windows registry keys and on both Windows and POSIX 197 // watch for changes in the paths that are expected to contain plugins. 198 #if defined(OS_WIN) 199 if (hkcu_key_.Create(HKEY_CURRENT_USER, 200 kRegistryMozillaPlugins, 201 KEY_NOTIFY) == ERROR_SUCCESS) { 202 if (hkcu_key_.StartWatching() == ERROR_SUCCESS) { 203 hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event())); 204 base::WaitableEventWatcher::EventCallback callback = 205 base::Bind(&PluginServiceImpl::OnWaitableEventSignaled, 206 base::Unretained(this)); 207 hkcu_watcher_.StartWatching(hkcu_event_.get(), callback); 208 } 209 } 210 if (hklm_key_.Create(HKEY_LOCAL_MACHINE, 211 kRegistryMozillaPlugins, 212 KEY_NOTIFY) == ERROR_SUCCESS) { 213 if (hklm_key_.StartWatching() == ERROR_SUCCESS) { 214 hklm_event_.reset(new base::WaitableEvent(hklm_key_.watch_event())); 215 base::WaitableEventWatcher::EventCallback callback = 216 base::Bind(&PluginServiceImpl::OnWaitableEventSignaled, 217 base::Unretained(this)); 218 hklm_watcher_.StartWatching(hklm_event_.get(), callback); 219 } 220 } 221 #endif 222 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID) 223 // On ChromeOS the user can't install plugins anyway and on Windows all 224 // important plugins register themselves in the registry so no need to do that. 225 226 // Get the list of all paths for registering the FilePathWatchers 227 // that will track and if needed reload the list of plugins on runtime. 228 std::vector<base::FilePath> plugin_dirs; 229 PluginList::Singleton()->GetPluginDirectories(&plugin_dirs); 230 231 for (size_t i = 0; i < plugin_dirs.size(); ++i) { 232 // FilePathWatcher can not handle non-absolute paths under windows. 233 // We don't watch for file changes in windows now but if this should ever 234 // be extended to Windows these lines might save some time of debugging. 235 #if defined(OS_WIN) 236 if (!plugin_dirs[i].IsAbsolute()) 237 continue; 238 #endif 239 FilePathWatcher* watcher = new FilePathWatcher(); 240 VLOG(1) << "Watching for changes in: " << plugin_dirs[i].value(); 241 BrowserThread::PostTask( 242 BrowserThread::FILE, FROM_HERE, 243 base::Bind(&PluginServiceImpl::RegisterFilePathWatcher, watcher, 244 plugin_dirs[i])); 245 file_watchers_.push_back(watcher); 246 } 247 #endif 248 } 249 250 PluginProcessHost* PluginServiceImpl::FindNpapiPluginProcess( 251 const base::FilePath& plugin_path) { 252 for (PluginProcessHostIterator iter; !iter.Done(); ++iter) { 253 if (iter->info().path == plugin_path) 254 return *iter; 255 } 256 257 return NULL; 258 } 259 260 PpapiPluginProcessHost* PluginServiceImpl::FindPpapiPluginProcess( 261 const base::FilePath& plugin_path, 262 const base::FilePath& profile_data_directory) { 263 for (PpapiPluginProcessHostIterator iter; !iter.Done(); ++iter) { 264 if (iter->plugin_path() == plugin_path && 265 iter->profile_data_directory() == profile_data_directory) { 266 return *iter; 267 } 268 } 269 return NULL; 270 } 271 272 PpapiPluginProcessHost* PluginServiceImpl::FindPpapiBrokerProcess( 273 const base::FilePath& broker_path) { 274 for (PpapiBrokerProcessHostIterator iter; !iter.Done(); ++iter) { 275 if (iter->plugin_path() == broker_path) 276 return *iter; 277 } 278 279 return NULL; 280 } 281 282 PluginProcessHost* PluginServiceImpl::FindOrStartNpapiPluginProcess( 283 int render_process_id, 284 const base::FilePath& plugin_path) { 285 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 286 287 if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path)) 288 return NULL; 289 290 PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path); 291 if (plugin_host) 292 return plugin_host; 293 294 WebPluginInfo info; 295 if (!GetPluginInfoByPath(plugin_path, &info)) { 296 return NULL; 297 } 298 299 // Record when NPAPI Flash process is started for the first time. 300 static bool counted = false; 301 if (!counted && base::UTF16ToUTF8(info.name) == kFlashPluginName) { 302 counted = true; 303 UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage", 304 START_NPAPI_FLASH_AT_LEAST_ONCE, 305 FLASH_USAGE_ENUM_COUNT); 306 } 307 #if defined(OS_CHROMEOS) 308 // TODO(ihf): Move to an earlier place once crbug.com/314301 is fixed. For now 309 // we still want Plugin.FlashUsage recorded if we end up here. 310 LOG(WARNING) << "Refusing to start npapi plugin on ChromeOS."; 311 return NULL; 312 #endif 313 // This plugin isn't loaded by any plugin process, so create a new process. 314 scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost()); 315 if (!new_host->Init(info)) { 316 NOTREACHED(); // Init is not expected to fail. 317 return NULL; 318 } 319 return new_host.release(); 320 } 321 322 PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiPluginProcess( 323 int render_process_id, 324 const base::FilePath& plugin_path, 325 const base::FilePath& profile_data_directory) { 326 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 327 328 if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path)) { 329 VLOG(1) << "Unable to load ppapi plugin: " << plugin_path.MaybeAsASCII(); 330 return NULL; 331 } 332 333 PpapiPluginProcessHost* plugin_host = 334 FindPpapiPluginProcess(plugin_path, profile_data_directory); 335 if (plugin_host) 336 return plugin_host; 337 338 // Validate that the plugin is actually registered. 339 PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path); 340 if (!info) { 341 VLOG(1) << "Unable to find ppapi plugin registration for: " 342 << plugin_path.MaybeAsASCII(); 343 return NULL; 344 } 345 346 // Record when PPAPI Flash process is started for the first time. 347 static bool counted = false; 348 if (!counted && info->name == kFlashPluginName) { 349 counted = true; 350 UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage", 351 START_PPAPI_FLASH_AT_LEAST_ONCE, 352 FLASH_USAGE_ENUM_COUNT); 353 } 354 355 // This plugin isn't loaded by any plugin process, so create a new process. 356 plugin_host = PpapiPluginProcessHost::CreatePluginHost( 357 *info, profile_data_directory); 358 if (!plugin_host) { 359 VLOG(1) << "Unable to create ppapi plugin process for: " 360 << plugin_path.MaybeAsASCII(); 361 } 362 363 return plugin_host; 364 } 365 366 PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiBrokerProcess( 367 int render_process_id, 368 const base::FilePath& plugin_path) { 369 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 370 371 if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path)) 372 return NULL; 373 374 PpapiPluginProcessHost* plugin_host = FindPpapiBrokerProcess(plugin_path); 375 if (plugin_host) 376 return plugin_host; 377 378 // Validate that the plugin is actually registered. 379 PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path); 380 if (!info) 381 return NULL; 382 383 // TODO(ddorwin): Uncomment once out of process is supported. 384 // DCHECK(info->is_out_of_process); 385 386 // This broker isn't loaded by any broker process, so create a new process. 387 return PpapiPluginProcessHost::CreateBrokerHost(*info); 388 } 389 390 void PluginServiceImpl::OpenChannelToNpapiPlugin( 391 int render_process_id, 392 int render_frame_id, 393 const GURL& url, 394 const GURL& page_url, 395 const std::string& mime_type, 396 PluginProcessHost::Client* client) { 397 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 398 DCHECK(!ContainsKey(pending_plugin_clients_, client)); 399 pending_plugin_clients_.insert(client); 400 401 // Make sure plugins are loaded if necessary. 402 PluginServiceFilterParams params = { 403 render_process_id, 404 render_frame_id, 405 page_url, 406 client->GetResourceContext() 407 }; 408 GetPlugins(base::Bind( 409 &PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin, 410 base::Unretained(this), params, url, mime_type, client)); 411 } 412 413 void PluginServiceImpl::OpenChannelToPpapiPlugin( 414 int render_process_id, 415 const base::FilePath& plugin_path, 416 const base::FilePath& profile_data_directory, 417 PpapiPluginProcessHost::PluginClient* client) { 418 PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess( 419 render_process_id, plugin_path, profile_data_directory); 420 if (plugin_host) { 421 plugin_host->OpenChannelToPlugin(client); 422 } else { 423 // Send error. 424 client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0); 425 } 426 } 427 428 void PluginServiceImpl::OpenChannelToPpapiBroker( 429 int render_process_id, 430 const base::FilePath& path, 431 PpapiPluginProcessHost::BrokerClient* client) { 432 PpapiPluginProcessHost* plugin_host = FindOrStartPpapiBrokerProcess( 433 render_process_id, path); 434 if (plugin_host) { 435 plugin_host->OpenChannelToPlugin(client); 436 } else { 437 // Send error. 438 client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0); 439 } 440 } 441 442 void PluginServiceImpl::CancelOpenChannelToNpapiPlugin( 443 PluginProcessHost::Client* client) { 444 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 445 DCHECK(ContainsKey(pending_plugin_clients_, client)); 446 pending_plugin_clients_.erase(client); 447 } 448 449 void PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin( 450 const PluginServiceFilterParams& params, 451 const GURL& url, 452 const std::string& mime_type, 453 PluginProcessHost::Client* client, 454 const std::vector<WebPluginInfo>&) { 455 GetAllowedPluginForOpenChannelToPlugin( 456 params.render_process_id, params.render_frame_id, url, params.page_url, 457 mime_type, client, params.resource_context); 458 } 459 460 void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin( 461 int render_process_id, 462 int render_frame_id, 463 const GURL& url, 464 const GURL& page_url, 465 const std::string& mime_type, 466 PluginProcessHost::Client* client, 467 ResourceContext* resource_context) { 468 WebPluginInfo info; 469 bool allow_wildcard = true; 470 bool found = GetPluginInfo( 471 render_process_id, render_frame_id, resource_context, 472 url, page_url, mime_type, allow_wildcard, 473 NULL, &info, NULL); 474 base::FilePath plugin_path; 475 if (found) 476 plugin_path = info.path; 477 478 // Now we jump back to the IO thread to finish opening the channel. 479 BrowserThread::PostTask( 480 BrowserThread::IO, FROM_HERE, 481 base::Bind(&PluginServiceImpl::FinishOpenChannelToPlugin, 482 base::Unretained(this), 483 render_process_id, 484 plugin_path, 485 client)); 486 } 487 488 void PluginServiceImpl::FinishOpenChannelToPlugin( 489 int render_process_id, 490 const base::FilePath& plugin_path, 491 PluginProcessHost::Client* client) { 492 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 493 494 // Make sure it hasn't been canceled yet. 495 if (!ContainsKey(pending_plugin_clients_, client)) 496 return; 497 pending_plugin_clients_.erase(client); 498 499 PluginProcessHost* plugin_host = FindOrStartNpapiPluginProcess( 500 render_process_id, plugin_path); 501 if (plugin_host) { 502 client->OnFoundPluginProcessHost(plugin_host); 503 plugin_host->OpenChannelToPlugin(client); 504 } else { 505 client->OnError(); 506 } 507 } 508 509 bool PluginServiceImpl::GetPluginInfoArray( 510 const GURL& url, 511 const std::string& mime_type, 512 bool allow_wildcard, 513 std::vector<WebPluginInfo>* plugins, 514 std::vector<std::string>* actual_mime_types) { 515 bool use_stale = false; 516 PluginList::Singleton()->GetPluginInfoArray( 517 url, mime_type, allow_wildcard, &use_stale, NPAPIPluginsSupported(), 518 plugins, actual_mime_types); 519 return use_stale; 520 } 521 522 bool PluginServiceImpl::GetPluginInfo(int render_process_id, 523 int render_frame_id, 524 ResourceContext* context, 525 const GURL& url, 526 const GURL& page_url, 527 const std::string& mime_type, 528 bool allow_wildcard, 529 bool* is_stale, 530 WebPluginInfo* info, 531 std::string* actual_mime_type) { 532 std::vector<WebPluginInfo> plugins; 533 std::vector<std::string> mime_types; 534 bool stale = GetPluginInfoArray( 535 url, mime_type, allow_wildcard, &plugins, &mime_types); 536 if (is_stale) 537 *is_stale = stale; 538 539 for (size_t i = 0; i < plugins.size(); ++i) { 540 if (!filter_ || filter_->IsPluginAvailable(render_process_id, 541 render_frame_id, 542 context, 543 url, 544 page_url, 545 &plugins[i])) { 546 *info = plugins[i]; 547 if (actual_mime_type) 548 *actual_mime_type = mime_types[i]; 549 return true; 550 } 551 } 552 return false; 553 } 554 555 bool PluginServiceImpl::GetPluginInfoByPath(const base::FilePath& plugin_path, 556 WebPluginInfo* info) { 557 std::vector<WebPluginInfo> plugins; 558 PluginList::Singleton()->GetPluginsNoRefresh(&plugins); 559 560 for (std::vector<WebPluginInfo>::iterator it = plugins.begin(); 561 it != plugins.end(); 562 ++it) { 563 if (it->path == plugin_path) { 564 *info = *it; 565 return true; 566 } 567 } 568 569 return false; 570 } 571 572 base::string16 PluginServiceImpl::GetPluginDisplayNameByPath( 573 const base::FilePath& path) { 574 base::string16 plugin_name = path.LossyDisplayName(); 575 WebPluginInfo info; 576 if (PluginService::GetInstance()->GetPluginInfoByPath(path, &info) && 577 !info.name.empty()) { 578 plugin_name = info.name; 579 #if defined(OS_MACOSX) 580 // Many plugins on the Mac have .plugin in the actual name, which looks 581 // terrible, so look for that and strip it off if present. 582 const std::string kPluginExtension = ".plugin"; 583 if (EndsWith(plugin_name, base::ASCIIToUTF16(kPluginExtension), true)) 584 plugin_name.erase(plugin_name.length() - kPluginExtension.length()); 585 #endif // OS_MACOSX 586 } 587 return plugin_name; 588 } 589 590 void PluginServiceImpl::GetPlugins(const GetPluginsCallback& callback) { 591 scoped_refptr<base::MessageLoopProxy> target_loop( 592 base::MessageLoop::current()->message_loop_proxy()); 593 594 if (LoadPluginListInProcess()) { 595 BrowserThread::GetBlockingPool()-> 596 PostSequencedWorkerTaskWithShutdownBehavior( 597 plugin_list_token_, 598 FROM_HERE, 599 base::Bind(&PluginServiceImpl::GetPluginsInternal, 600 base::Unretained(this), 601 target_loop, callback), 602 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); 603 return; 604 } 605 #if defined(OS_POSIX) 606 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, 607 base::Bind(&PluginServiceImpl::GetPluginsOnIOThread, 608 base::Unretained(this), target_loop, callback)); 609 #else 610 NOTREACHED(); 611 #endif 612 } 613 614 void PluginServiceImpl::GetPluginsInternal( 615 base::MessageLoopProxy* target_loop, 616 const PluginService::GetPluginsCallback& callback) { 617 DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread( 618 plugin_list_token_)); 619 620 std::vector<WebPluginInfo> plugins; 621 PluginList::Singleton()->GetPlugins(&plugins, NPAPIPluginsSupported()); 622 623 target_loop->PostTask(FROM_HERE, 624 base::Bind(callback, plugins)); 625 } 626 627 #if defined(OS_POSIX) 628 void PluginServiceImpl::GetPluginsOnIOThread( 629 base::MessageLoopProxy* target_loop, 630 const GetPluginsCallback& callback) { 631 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 632 633 // If we switch back to loading plugins in process, then we need to make 634 // sure g_thread_init() gets called since plugins may call glib at load. 635 636 if (!plugin_loader_) 637 plugin_loader_ = new PluginLoaderPosix; 638 639 plugin_loader_->GetPlugins( 640 base::Bind(&ForwardCallback, make_scoped_refptr(target_loop), callback)); 641 } 642 #endif 643 644 void PluginServiceImpl::OnWaitableEventSignaled( 645 base::WaitableEvent* waitable_event) { 646 #if defined(OS_WIN) 647 if (waitable_event == hkcu_event_) { 648 hkcu_key_.StartWatching(); 649 } else { 650 hklm_key_.StartWatching(); 651 } 652 653 PluginList::Singleton()->RefreshPlugins(); 654 PurgePluginListCache(NULL, false); 655 #else 656 // This event should only get signaled on a Windows machine. 657 NOTREACHED(); 658 #endif // defined(OS_WIN) 659 } 660 661 void PluginServiceImpl::RegisterPepperPlugins() { 662 ComputePepperPluginList(&ppapi_plugins_); 663 for (size_t i = 0; i < ppapi_plugins_.size(); ++i) { 664 RegisterInternalPlugin(ppapi_plugins_[i].ToWebPluginInfo(), true); 665 } 666 } 667 668 // There should generally be very few plugins so a brute-force search is fine. 669 PepperPluginInfo* PluginServiceImpl::GetRegisteredPpapiPluginInfo( 670 const base::FilePath& plugin_path) { 671 PepperPluginInfo* info = NULL; 672 for (size_t i = 0; i < ppapi_plugins_.size(); ++i) { 673 if (ppapi_plugins_[i].path == plugin_path) { 674 info = &ppapi_plugins_[i]; 675 break; 676 } 677 } 678 if (info) 679 return info; 680 // We did not find the plugin in our list. But wait! the plugin can also 681 // be a latecomer, as it happens with pepper flash. This information 682 // can be obtained from the PluginList singleton and we can use it to 683 // construct it and add it to the list. This same deal needs to be done 684 // in the renderer side in PepperPluginRegistry. 685 WebPluginInfo webplugin_info; 686 if (!GetPluginInfoByPath(plugin_path, &webplugin_info)) 687 return NULL; 688 PepperPluginInfo new_pepper_info; 689 if (!MakePepperPluginInfo(webplugin_info, &new_pepper_info)) 690 return NULL; 691 ppapi_plugins_.push_back(new_pepper_info); 692 return &ppapi_plugins_[ppapi_plugins_.size() - 1]; 693 } 694 695 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID) 696 // static 697 void PluginServiceImpl::RegisterFilePathWatcher(FilePathWatcher* watcher, 698 const base::FilePath& path) { 699 bool result = watcher->Watch(path, false, 700 base::Bind(&NotifyPluginDirChanged)); 701 DCHECK(result); 702 } 703 #endif 704 705 void PluginServiceImpl::SetFilter(PluginServiceFilter* filter) { 706 filter_ = filter; 707 } 708 709 PluginServiceFilter* PluginServiceImpl::GetFilter() { 710 return filter_; 711 } 712 713 void PluginServiceImpl::ForcePluginShutdown(const base::FilePath& plugin_path) { 714 if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) { 715 BrowserThread::PostTask( 716 BrowserThread::IO, FROM_HERE, 717 base::Bind(&PluginServiceImpl::ForcePluginShutdown, 718 base::Unretained(this), plugin_path)); 719 return; 720 } 721 722 PluginProcessHost* plugin = FindNpapiPluginProcess(plugin_path); 723 if (plugin) 724 plugin->ForceShutdown(); 725 } 726 727 static const unsigned int kMaxCrashesPerInterval = 3; 728 static const unsigned int kCrashesInterval = 120; 729 730 void PluginServiceImpl::RegisterPluginCrash(const base::FilePath& path) { 731 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 732 std::map<base::FilePath, std::vector<base::Time> >::iterator i = 733 crash_times_.find(path); 734 if (i == crash_times_.end()) { 735 crash_times_[path] = std::vector<base::Time>(); 736 i = crash_times_.find(path); 737 } 738 if (i->second.size() == kMaxCrashesPerInterval) { 739 i->second.erase(i->second.begin()); 740 } 741 base::Time time = base::Time::Now(); 742 i->second.push_back(time); 743 } 744 745 bool PluginServiceImpl::IsPluginUnstable(const base::FilePath& path) { 746 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 747 std::map<base::FilePath, std::vector<base::Time> >::const_iterator i = 748 crash_times_.find(path); 749 if (i == crash_times_.end()) { 750 return false; 751 } 752 if (i->second.size() != kMaxCrashesPerInterval) { 753 return false; 754 } 755 base::TimeDelta delta = base::Time::Now() - i->second[0]; 756 return delta.InSeconds() <= kCrashesInterval; 757 } 758 759 void PluginServiceImpl::RefreshPlugins() { 760 PluginList::Singleton()->RefreshPlugins(); 761 } 762 763 void PluginServiceImpl::AddExtraPluginPath(const base::FilePath& path) { 764 if (!NPAPIPluginsSupported()) { 765 // TODO(jam): remove and just have CHECK once we're sure this doesn't get 766 // triggered. 767 DVLOG(0) << "NPAPI plugins not supported"; 768 return; 769 } 770 PluginList::Singleton()->AddExtraPluginPath(path); 771 } 772 773 void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) { 774 PluginList::Singleton()->RemoveExtraPluginPath(path); 775 } 776 777 void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) { 778 PluginList::Singleton()->AddExtraPluginDir(path); 779 } 780 781 void PluginServiceImpl::RegisterInternalPlugin( 782 const WebPluginInfo& info, 783 bool add_at_beginning) { 784 if (!NPAPIPluginsSupported() && 785 info.type == WebPluginInfo::PLUGIN_TYPE_NPAPI) { 786 DVLOG(0) << "Don't register NPAPI plugins when they're not supported"; 787 return; 788 } 789 PluginList::Singleton()->RegisterInternalPlugin(info, add_at_beginning); 790 } 791 792 void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) { 793 PluginList::Singleton()->UnregisterInternalPlugin(path); 794 } 795 796 void PluginServiceImpl::GetInternalPlugins( 797 std::vector<WebPluginInfo>* plugins) { 798 PluginList::Singleton()->GetInternalPlugins(plugins); 799 } 800 801 bool PluginServiceImpl::NPAPIPluginsSupported() { 802 #if defined(OS_WIN) || defined(OS_MACOSX) 803 return true; 804 #else 805 return false; 806 #endif 807 } 808 809 void PluginServiceImpl::DisablePluginsDiscoveryForTesting() { 810 PluginList::Singleton()->DisablePluginsDiscovery(); 811 } 812 813 #if defined(OS_MACOSX) 814 void PluginServiceImpl::AppActivated() { 815 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, 816 base::Bind(&NotifyPluginsOfActivation)); 817 } 818 #elif defined(OS_WIN) 819 820 bool GetPluginPropertyFromWindow( 821 HWND window, const wchar_t* plugin_atom_property, 822 base::string16* plugin_property) { 823 ATOM plugin_atom = reinterpret_cast<ATOM>( 824 GetPropW(window, plugin_atom_property)); 825 if (plugin_atom != 0) { 826 WCHAR plugin_property_local[MAX_PATH] = {0}; 827 GlobalGetAtomNameW(plugin_atom, 828 plugin_property_local, 829 ARRAYSIZE(plugin_property_local)); 830 *plugin_property = plugin_property_local; 831 return true; 832 } 833 return false; 834 } 835 836 bool PluginServiceImpl::GetPluginInfoFromWindow( 837 HWND window, 838 base::string16* plugin_name, 839 base::string16* plugin_version) { 840 if (!IsPluginWindow(window)) 841 return false; 842 843 GetPluginPropertyFromWindow( 844 window, kPluginNameAtomProperty, plugin_name); 845 GetPluginPropertyFromWindow( 846 window, kPluginVersionAtomProperty, plugin_version); 847 return true; 848 } 849 850 bool PluginServiceImpl::IsPluginWindow(HWND window) { 851 return gfx::GetClassName(window) == base::string16(kNativeWindowClassName); 852 } 853 #endif 854 855 bool PluginServiceImpl::PpapiDevChannelSupported( 856 BrowserContext* browser_context, 857 const GURL& document_url) { 858 return content::GetContentClient()->browser()-> 859 IsPluginAllowedToUseDevChannelAPIs(browser_context, document_url); 860 } 861 862 } // namespace content 863