Home | History | Annotate | Download | only in browser 
      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 base::CommandLine* command_line =
    182       base::CommandLine::ForCurrentProcess();
    183   base::FilePath path =
    184       command_line->GetSwitchValuePath(switches::kLoadPlugin);
    185   if (!path.empty())
    186     AddExtraPluginPath(path);
    187   path = command_line->GetSwitchValuePath(switches::kExtraPluginDir);
    188   if (!path.empty())
    189     PluginList::Singleton()->AddExtraPluginDir(path);
    190 
    191   if (command_line->HasSwitch(switches::kDisablePluginsDiscovery))
    192     PluginList::Singleton()->DisablePluginsDiscovery();
    193 }
    194 
    195 void PluginServiceImpl::StartWatchingPlugins() {
    196   // Start watching for changes in the plugin list. This means watching
    197   // for changes in the Windows registry keys and on both Windows and POSIX
    198   // watch for changes in the paths that are expected to contain plugins.
    199 #if defined(OS_WIN)
    200   if (hkcu_key_.Create(HKEY_CURRENT_USER,
    201                        kRegistryMozillaPlugins,
    202                        KEY_NOTIFY) == ERROR_SUCCESS) {
    203     if (hkcu_key_.StartWatching() == ERROR_SUCCESS) {
    204       hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
    205       base::WaitableEventWatcher::EventCallback callback =
    206             base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
    207                        base::Unretained(this));
    208       hkcu_watcher_.StartWatching(hkcu_event_.get(), callback);
    209     }
    210   }
    211   if (hklm_key_.Create(HKEY_LOCAL_MACHINE,
    212                        kRegistryMozillaPlugins,
    213                        KEY_NOTIFY) == ERROR_SUCCESS) {
    214     if (hklm_key_.StartWatching() == ERROR_SUCCESS) {
    215       hklm_event_.reset(new base::WaitableEvent(hklm_key_.watch_event()));
    216       base::WaitableEventWatcher::EventCallback callback =
    217             base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
    218                        base::Unretained(this));
    219       hklm_watcher_.StartWatching(hklm_event_.get(), callback);
    220     }
    221   }
    222 #endif
    223 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
    224 // On ChromeOS the user can't install plugins anyway and on Windows all
    225 // important plugins register themselves in the registry so no need to do that.
    226 
    227   // Get the list of all paths for registering the FilePathWatchers
    228   // that will track and if needed reload the list of plugins on runtime.
    229   std::vector<base::FilePath> plugin_dirs;
    230   PluginList::Singleton()->GetPluginDirectories(&plugin_dirs);
    231 
    232   for (size_t i = 0; i < plugin_dirs.size(); ++i) {
    233     // FilePathWatcher can not handle non-absolute paths under windows.
    234     // We don't watch for file changes in windows now but if this should ever
    235     // be extended to Windows these lines might save some time of debugging.
    236 #if defined(OS_WIN)
    237     if (!plugin_dirs[i].IsAbsolute())
    238       continue;
    239 #endif
    240     FilePathWatcher* watcher = new FilePathWatcher();
    241     VLOG(1) << "Watching for changes in: " << plugin_dirs[i].value();
    242     BrowserThread::PostTask(
    243         BrowserThread::FILE, FROM_HERE,
    244         base::Bind(&PluginServiceImpl::RegisterFilePathWatcher, watcher,
    245                    plugin_dirs[i]));
    246     file_watchers_.push_back(watcher);
    247   }
    248 #endif
    249 }
    250 
    251 PluginProcessHost* PluginServiceImpl::FindNpapiPluginProcess(
    252     const base::FilePath& plugin_path) {
    253   for (PluginProcessHostIterator iter; !iter.Done(); ++iter) {
    254     if (iter->info().path == plugin_path)
    255       return *iter;
    256   }
    257 
    258   return NULL;
    259 }
    260 
    261 PpapiPluginProcessHost* PluginServiceImpl::FindPpapiPluginProcess(
    262     const base::FilePath& plugin_path,
    263     const base::FilePath& profile_data_directory) {
    264   for (PpapiPluginProcessHostIterator iter; !iter.Done(); ++iter) {
    265     if (iter->plugin_path() == plugin_path &&
    266         iter->profile_data_directory() == profile_data_directory) {
    267       return *iter;
    268     }
    269   }
    270   return NULL;
    271 }
    272 
    273 PpapiPluginProcessHost* PluginServiceImpl::FindPpapiBrokerProcess(
    274     const base::FilePath& broker_path) {
    275   for (PpapiBrokerProcessHostIterator iter; !iter.Done(); ++iter) {
    276     if (iter->plugin_path() == broker_path)
    277       return *iter;
    278   }
    279 
    280   return NULL;
    281 }
    282 
    283 PluginProcessHost* PluginServiceImpl::FindOrStartNpapiPluginProcess(
    284     int render_process_id,
    285     const base::FilePath& plugin_path) {
    286   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    287 
    288   if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path))
    289     return NULL;
    290 
    291   PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path);
    292   if (plugin_host)
    293     return plugin_host;
    294 
    295   WebPluginInfo info;
    296   if (!GetPluginInfoByPath(plugin_path, &info)) {
    297     return NULL;
    298   }
    299 
    300   // Record when NPAPI Flash process is started for the first time.
    301   static bool counted = false;
    302   if (!counted && base::UTF16ToUTF8(info.name) == kFlashPluginName) {
    303     counted = true;
    304     UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage",
    305                               START_NPAPI_FLASH_AT_LEAST_ONCE,
    306                               FLASH_USAGE_ENUM_COUNT);
    307   }
    308 #if defined(OS_CHROMEOS)
    309   // TODO(ihf): Move to an earlier place once crbug.com/314301 is fixed. For now
    310   // we still want Plugin.FlashUsage recorded if we end up here.
    311   LOG(WARNING) << "Refusing to start npapi plugin on ChromeOS.";
    312   return NULL;
    313 #endif
    314   // This plugin isn't loaded by any plugin process, so create a new process.
    315   scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost());
    316   if (!new_host->Init(info)) {
    317     NOTREACHED();  // Init is not expected to fail.
    318     return NULL;
    319   }
    320   return new_host.release();
    321 }
    322 
    323 PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiPluginProcess(
    324     int render_process_id,
    325     const base::FilePath& plugin_path,
    326     const base::FilePath& profile_data_directory) {
    327   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    328 
    329   if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path)) {
    330     VLOG(1) << "Unable to load ppapi plugin: " << plugin_path.MaybeAsASCII();
    331     return NULL;
    332   }
    333 
    334   PpapiPluginProcessHost* plugin_host =
    335       FindPpapiPluginProcess(plugin_path, profile_data_directory);
    336   if (plugin_host)
    337     return plugin_host;
    338 
    339   // Validate that the plugin is actually registered.
    340   PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
    341   if (!info) {
    342     VLOG(1) << "Unable to find ppapi plugin registration for: "
    343             << plugin_path.MaybeAsASCII();
    344     return NULL;
    345   }
    346 
    347   // Record when PPAPI Flash process is started for the first time.
    348   static bool counted = false;
    349   if (!counted && info->name == kFlashPluginName) {
    350     counted = true;
    351     UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage",
    352                               START_PPAPI_FLASH_AT_LEAST_ONCE,
    353                               FLASH_USAGE_ENUM_COUNT);
    354   }
    355 
    356   // This plugin isn't loaded by any plugin process, so create a new process.
    357   plugin_host = PpapiPluginProcessHost::CreatePluginHost(
    358       *info, profile_data_directory);
    359   if (!plugin_host) {
    360     VLOG(1) << "Unable to create ppapi plugin process for: "
    361             << plugin_path.MaybeAsASCII();
    362   }
    363 
    364   return plugin_host;
    365 }
    366 
    367 PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiBrokerProcess(
    368     int render_process_id,
    369     const base::FilePath& plugin_path) {
    370   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    371 
    372   if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path))
    373     return NULL;
    374 
    375   PpapiPluginProcessHost* plugin_host = FindPpapiBrokerProcess(plugin_path);
    376   if (plugin_host)
    377     return plugin_host;
    378 
    379   // Validate that the plugin is actually registered.
    380   PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
    381   if (!info)
    382     return NULL;
    383 
    384   // TODO(ddorwin): Uncomment once out of process is supported.
    385   // DCHECK(info->is_out_of_process);
    386 
    387   // This broker isn't loaded by any broker process, so create a new process.
    388   return PpapiPluginProcessHost::CreateBrokerHost(*info);
    389 }
    390 
    391 void PluginServiceImpl::OpenChannelToNpapiPlugin(
    392     int render_process_id,
    393     int render_frame_id,
    394     const GURL& url,
    395     const GURL& page_url,
    396     const std::string& mime_type,
    397     PluginProcessHost::Client* client) {
    398   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    399   DCHECK(!ContainsKey(pending_plugin_clients_, client));
    400   pending_plugin_clients_.insert(client);
    401 
    402   // Make sure plugins are loaded if necessary.
    403   PluginServiceFilterParams params = {
    404     render_process_id,
    405     render_frame_id,
    406     page_url,
    407     client->GetResourceContext()
    408   };
    409   GetPlugins(base::Bind(
    410       &PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin,
    411       base::Unretained(this), params, url, mime_type, client));
    412 }
    413 
    414 void PluginServiceImpl::OpenChannelToPpapiPlugin(
    415     int render_process_id,
    416     const base::FilePath& plugin_path,
    417     const base::FilePath& profile_data_directory,
    418     PpapiPluginProcessHost::PluginClient* client) {
    419   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess(
    420       render_process_id, plugin_path, profile_data_directory);
    421   if (plugin_host) {
    422     plugin_host->OpenChannelToPlugin(client);
    423   } else {
    424     // Send error.
    425     client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0);
    426   }
    427 }
    428 
    429 void PluginServiceImpl::OpenChannelToPpapiBroker(
    430     int render_process_id,
    431     const base::FilePath& path,
    432     PpapiPluginProcessHost::BrokerClient* client) {
    433   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiBrokerProcess(
    434       render_process_id, path);
    435   if (plugin_host) {
    436     plugin_host->OpenChannelToPlugin(client);
    437   } else {
    438     // Send error.
    439     client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0);
    440   }
    441 }
    442 
    443 void PluginServiceImpl::CancelOpenChannelToNpapiPlugin(
    444     PluginProcessHost::Client* client) {
    445   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    446   DCHECK(ContainsKey(pending_plugin_clients_, client));
    447   pending_plugin_clients_.erase(client);
    448 }
    449 
    450 void PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin(
    451     const PluginServiceFilterParams& params,
    452     const GURL& url,
    453     const std::string& mime_type,
    454     PluginProcessHost::Client* client,
    455     const std::vector<WebPluginInfo>&) {
    456   GetAllowedPluginForOpenChannelToPlugin(
    457       params.render_process_id, params.render_frame_id, url, params.page_url,
    458       mime_type, client, params.resource_context);
    459 }
    460 
    461 void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin(
    462     int render_process_id,
    463     int render_frame_id,
    464     const GURL& url,
    465     const GURL& page_url,
    466     const std::string& mime_type,
    467     PluginProcessHost::Client* client,
    468     ResourceContext* resource_context) {
    469   WebPluginInfo info;
    470   bool allow_wildcard = true;
    471   bool found = GetPluginInfo(
    472       render_process_id, render_frame_id, resource_context,
    473       url, page_url, mime_type, allow_wildcard,
    474       NULL, &info, NULL);
    475   base::FilePath plugin_path;
    476   if (found)
    477     plugin_path = info.path;
    478 
    479   // Now we jump back to the IO thread to finish opening the channel.
    480   BrowserThread::PostTask(
    481       BrowserThread::IO, FROM_HERE,
    482       base::Bind(&PluginServiceImpl::FinishOpenChannelToPlugin,
    483                  base::Unretained(this),
    484                  render_process_id,
    485                  plugin_path,
    486                  client));
    487 }
    488 
    489 void PluginServiceImpl::FinishOpenChannelToPlugin(
    490     int render_process_id,
    491     const base::FilePath& plugin_path,
    492     PluginProcessHost::Client* client) {
    493   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    494 
    495   // Make sure it hasn't been canceled yet.
    496   if (!ContainsKey(pending_plugin_clients_, client))
    497     return;
    498   pending_plugin_clients_.erase(client);
    499 
    500   PluginProcessHost* plugin_host = FindOrStartNpapiPluginProcess(
    501       render_process_id, plugin_path);
    502   if (plugin_host) {
    503     client->OnFoundPluginProcessHost(plugin_host);
    504     plugin_host->OpenChannelToPlugin(client);
    505   } else {
    506     client->OnError();
    507   }
    508 }
    509 
    510 bool PluginServiceImpl::GetPluginInfoArray(
    511     const GURL& url,
    512     const std::string& mime_type,
    513     bool allow_wildcard,
    514     std::vector<WebPluginInfo>* plugins,
    515     std::vector<std::string>* actual_mime_types) {
    516   bool use_stale = false;
    517   PluginList::Singleton()->GetPluginInfoArray(
    518       url, mime_type, allow_wildcard, &use_stale, NPAPIPluginsSupported(),
    519       plugins, actual_mime_types);
    520   return use_stale;
    521 }
    522 
    523 bool PluginServiceImpl::GetPluginInfo(int render_process_id,
    524                                       int render_frame_id,
    525                                       ResourceContext* context,
    526                                       const GURL& url,
    527                                       const GURL& page_url,
    528                                       const std::string& mime_type,
    529                                       bool allow_wildcard,
    530                                       bool* is_stale,
    531                                       WebPluginInfo* info,
    532                                       std::string* actual_mime_type) {
    533   std::vector<WebPluginInfo> plugins;
    534   std::vector<std::string> mime_types;
    535   bool stale = GetPluginInfoArray(
    536       url, mime_type, allow_wildcard, &plugins, &mime_types);
    537   if (is_stale)
    538     *is_stale = stale;
    539 
    540   for (size_t i = 0; i < plugins.size(); ++i) {
    541     if (!filter_ || filter_->IsPluginAvailable(render_process_id,
    542                                                render_frame_id,
    543                                                context,
    544                                                url,
    545                                                page_url,
    546                                                &plugins[i])) {
    547       *info = plugins[i];
    548       if (actual_mime_type)
    549         *actual_mime_type = mime_types[i];
    550       return true;
    551     }
    552   }
    553   return false;
    554 }
    555 
    556 bool PluginServiceImpl::GetPluginInfoByPath(const base::FilePath& plugin_path,
    557                                             WebPluginInfo* info) {
    558   std::vector<WebPluginInfo> plugins;
    559   PluginList::Singleton()->GetPluginsNoRefresh(&plugins);
    560 
    561   for (std::vector<WebPluginInfo>::iterator it = plugins.begin();
    562        it != plugins.end();
    563        ++it) {
    564     if (it->path == plugin_path) {
    565       *info = *it;
    566       return true;
    567     }
    568   }
    569 
    570   return false;
    571 }
    572 
    573 base::string16 PluginServiceImpl::GetPluginDisplayNameByPath(
    574     const base::FilePath& path) {
    575   base::string16 plugin_name = path.LossyDisplayName();
    576   WebPluginInfo info;
    577   if (PluginService::GetInstance()->GetPluginInfoByPath(path, &info) &&
    578       !info.name.empty()) {
    579     plugin_name = info.name;
    580 #if defined(OS_MACOSX)
    581     // Many plugins on the Mac have .plugin in the actual name, which looks
    582     // terrible, so look for that and strip it off if present.
    583     const std::string kPluginExtension = ".plugin";
    584     if (EndsWith(plugin_name, base::ASCIIToUTF16(kPluginExtension), true))
    585       plugin_name.erase(plugin_name.length() - kPluginExtension.length());
    586 #endif  // OS_MACOSX
    587   }
    588   return plugin_name;
    589 }
    590 
    591 void PluginServiceImpl::GetPlugins(const GetPluginsCallback& callback) {
    592   scoped_refptr<base::MessageLoopProxy> target_loop(
    593       base::MessageLoop::current()->message_loop_proxy());
    594 
    595   if (LoadPluginListInProcess()) {
    596     BrowserThread::GetBlockingPool()->
    597         PostSequencedWorkerTaskWithShutdownBehavior(
    598             plugin_list_token_,
    599             FROM_HERE,
    600             base::Bind(&PluginServiceImpl::GetPluginsInternal,
    601                        base::Unretained(this),
    602                        target_loop, callback),
    603         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
    604     return;
    605   }
    606 #if defined(OS_POSIX)
    607   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
    608       base::Bind(&PluginServiceImpl::GetPluginsOnIOThread,
    609                  base::Unretained(this), target_loop, callback));
    610 #else
    611   NOTREACHED();
    612 #endif
    613 }
    614 
    615 void PluginServiceImpl::GetPluginsInternal(
    616      base::MessageLoopProxy* target_loop,
    617      const PluginService::GetPluginsCallback& callback) {
    618   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    619       plugin_list_token_));
    620 
    621   std::vector<WebPluginInfo> plugins;
    622   PluginList::Singleton()->GetPlugins(&plugins, NPAPIPluginsSupported());
    623 
    624   target_loop->PostTask(FROM_HERE,
    625       base::Bind(callback, plugins));
    626 }
    627 
    628 #if defined(OS_POSIX)
    629 void PluginServiceImpl::GetPluginsOnIOThread(
    630     base::MessageLoopProxy* target_loop,
    631     const GetPluginsCallback& callback) {
    632   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    633 
    634   // If we switch back to loading plugins in process, then we need to make
    635   // sure g_thread_init() gets called since plugins may call glib at load.
    636 
    637   if (!plugin_loader_.get())
    638     plugin_loader_ = new PluginLoaderPosix;
    639 
    640   plugin_loader_->GetPlugins(
    641       base::Bind(&ForwardCallback, make_scoped_refptr(target_loop), callback));
    642 }
    643 #endif
    644 
    645 void PluginServiceImpl::OnWaitableEventSignaled(
    646     base::WaitableEvent* waitable_event) {
    647 #if defined(OS_WIN)
    648   if (waitable_event == hkcu_event_) {
    649     hkcu_key_.StartWatching();
    650   } else {
    651     hklm_key_.StartWatching();
    652   }
    653 
    654   PluginList::Singleton()->RefreshPlugins();
    655   PurgePluginListCache(NULL, false);
    656 #else
    657   // This event should only get signaled on a Windows machine.
    658   NOTREACHED();
    659 #endif  // defined(OS_WIN)
    660 }
    661 
    662 void PluginServiceImpl::RegisterPepperPlugins() {
    663   ComputePepperPluginList(&ppapi_plugins_);
    664   for (size_t i = 0; i < ppapi_plugins_.size(); ++i) {
    665     RegisterInternalPlugin(ppapi_plugins_[i].ToWebPluginInfo(), true);
    666   }
    667 }
    668 
    669 // There should generally be very few plugins so a brute-force search is fine.
    670 PepperPluginInfo* PluginServiceImpl::GetRegisteredPpapiPluginInfo(
    671     const base::FilePath& plugin_path) {
    672   PepperPluginInfo* info = NULL;
    673   for (size_t i = 0; i < ppapi_plugins_.size(); ++i) {
    674     if (ppapi_plugins_[i].path == plugin_path) {
    675       info = &ppapi_plugins_[i];
    676       break;
    677     }
    678   }
    679   if (info)
    680     return info;
    681   // We did not find the plugin in our list. But wait! the plugin can also
    682   // be a latecomer, as it happens with pepper flash. This information
    683   // can be obtained from the PluginList singleton and we can use it to
    684   // construct it and add it to the list. This same deal needs to be done
    685   // in the renderer side in PepperPluginRegistry.
    686   WebPluginInfo webplugin_info;
    687   if (!GetPluginInfoByPath(plugin_path, &webplugin_info))
    688     return NULL;
    689   PepperPluginInfo new_pepper_info;
    690   if (!MakePepperPluginInfo(webplugin_info, &new_pepper_info))
    691     return NULL;
    692   ppapi_plugins_.push_back(new_pepper_info);
    693   return &ppapi_plugins_[ppapi_plugins_.size() - 1];
    694 }
    695 
    696 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
    697 // static
    698 void PluginServiceImpl::RegisterFilePathWatcher(FilePathWatcher* watcher,
    699                                                 const base::FilePath& path) {
    700   bool result = watcher->Watch(path, false,
    701                                base::Bind(&NotifyPluginDirChanged));
    702   DCHECK(result);
    703 }
    704 #endif
    705 
    706 void PluginServiceImpl::SetFilter(PluginServiceFilter* filter) {
    707   filter_ = filter;
    708 }
    709 
    710 PluginServiceFilter* PluginServiceImpl::GetFilter() {
    711   return filter_;
    712 }
    713 
    714 void PluginServiceImpl::ForcePluginShutdown(const base::FilePath& plugin_path) {
    715   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
    716     BrowserThread::PostTask(
    717         BrowserThread::IO, FROM_HERE,
    718         base::Bind(&PluginServiceImpl::ForcePluginShutdown,
    719                    base::Unretained(this), plugin_path));
    720     return;
    721   }
    722 
    723   PluginProcessHost* plugin = FindNpapiPluginProcess(plugin_path);
    724   if (plugin)
    725     plugin->ForceShutdown();
    726 }
    727 
    728 static const unsigned int kMaxCrashesPerInterval = 3;
    729 static const unsigned int kCrashesInterval = 120;
    730 
    731 void PluginServiceImpl::RegisterPluginCrash(const base::FilePath& path) {
    732   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    733   std::map<base::FilePath, std::vector<base::Time> >::iterator i =
    734       crash_times_.find(path);
    735   if (i == crash_times_.end()) {
    736     crash_times_[path] = std::vector<base::Time>();
    737     i = crash_times_.find(path);
    738   }
    739   if (i->second.size() == kMaxCrashesPerInterval) {
    740     i->second.erase(i->second.begin());
    741   }
    742   base::Time time = base::Time::Now();
    743   i->second.push_back(time);
    744 }
    745 
    746 bool PluginServiceImpl::IsPluginUnstable(const base::FilePath& path) {
    747   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    748   std::map<base::FilePath, std::vector<base::Time> >::const_iterator i =
    749       crash_times_.find(path);
    750   if (i == crash_times_.end()) {
    751     return false;
    752   }
    753   if (i->second.size() != kMaxCrashesPerInterval) {
    754     return false;
    755   }
    756   base::TimeDelta delta = base::Time::Now() - i->second[0];
    757   return delta.InSeconds() <= kCrashesInterval;
    758 }
    759 
    760 void PluginServiceImpl::RefreshPlugins() {
    761   PluginList::Singleton()->RefreshPlugins();
    762 }
    763 
    764 void PluginServiceImpl::AddExtraPluginPath(const base::FilePath& path) {
    765   if (!NPAPIPluginsSupported()) {
    766     // TODO(jam): remove and just have CHECK once we're sure this doesn't get
    767     // triggered.
    768     DVLOG(0) << "NPAPI plugins not supported";
    769     return;
    770   }
    771   PluginList::Singleton()->AddExtraPluginPath(path);
    772 }
    773 
    774 void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
    775   PluginList::Singleton()->RemoveExtraPluginPath(path);
    776 }
    777 
    778 void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) {
    779   PluginList::Singleton()->AddExtraPluginDir(path);
    780 }
    781 
    782 void PluginServiceImpl::RegisterInternalPlugin(
    783     const WebPluginInfo& info,
    784     bool add_at_beginning) {
    785   if (!NPAPIPluginsSupported() &&
    786       info.type == WebPluginInfo::PLUGIN_TYPE_NPAPI) {
    787     DVLOG(0) << "Don't register NPAPI plugins when they're not supported";
    788     return;
    789   }
    790   PluginList::Singleton()->RegisterInternalPlugin(info, add_at_beginning);
    791 }
    792 
    793 void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) {
    794   PluginList::Singleton()->UnregisterInternalPlugin(path);
    795 }
    796 
    797 void PluginServiceImpl::GetInternalPlugins(
    798     std::vector<WebPluginInfo>* plugins) {
    799   PluginList::Singleton()->GetInternalPlugins(plugins);
    800 }
    801 
    802 bool PluginServiceImpl::NPAPIPluginsSupported() {
    803 #if defined(OS_WIN) || defined(OS_MACOSX)
    804   return true;
    805 #else
    806   return false;
    807 #endif
    808 }
    809 
    810 void PluginServiceImpl::DisablePluginsDiscoveryForTesting() {
    811   PluginList::Singleton()->DisablePluginsDiscovery();
    812 }
    813 
    814 #if defined(OS_MACOSX)
    815 void PluginServiceImpl::AppActivated() {
    816   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
    817                           base::Bind(&NotifyPluginsOfActivation));
    818 }
    819 #elif defined(OS_WIN)
    820 
    821 bool GetPluginPropertyFromWindow(
    822     HWND window, const wchar_t* plugin_atom_property,
    823     base::string16* plugin_property) {
    824   ATOM plugin_atom = reinterpret_cast<ATOM>(
    825       GetPropW(window, plugin_atom_property));
    826   if (plugin_atom != 0) {
    827     WCHAR plugin_property_local[MAX_PATH] = {0};
    828     GlobalGetAtomNameW(plugin_atom,
    829                        plugin_property_local,
    830                        ARRAYSIZE(plugin_property_local));
    831     *plugin_property = plugin_property_local;
    832     return true;
    833   }
    834   return false;
    835 }
    836 
    837 bool PluginServiceImpl::GetPluginInfoFromWindow(
    838     HWND window,
    839     base::string16* plugin_name,
    840     base::string16* plugin_version) {
    841   if (!IsPluginWindow(window))
    842     return false;
    843 
    844 
    845   DWORD process_id = 0;
    846   GetWindowThreadProcessId(window, &process_id);
    847   WebPluginInfo info;
    848   if (!PluginProcessHost::GetWebPluginInfoFromPluginPid(process_id, &info))
    849     return false;
    850 
    851   *plugin_name = info.name;
    852   *plugin_version = info.version;
    853   return true;
    854 }
    855 
    856 bool PluginServiceImpl::IsPluginWindow(HWND window) {
    857   return gfx::GetClassName(window) == base::string16(kNativeWindowClassName);
    858 }
    859 #endif
    860 
    861 bool PluginServiceImpl::PpapiDevChannelSupported(
    862     BrowserContext* browser_context,
    863     const GURL& document_url) {
    864   return content::GetContentClient()->browser()->
    865       IsPluginAllowedToUseDevChannelAPIs(browser_context, document_url);
    866 }
    867 
    868 }  // namespace content
    869