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)
44using ::base::FilePathWatcher;
45#endif
46
47namespace content {
48namespace {
49
50// This enum is used to collect Flash usage data.
51enum 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
63bool 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.
81void 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)
92void 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)
101void 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
118void 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
127PluginService* PluginService::GetInstance() {
128  return PluginServiceImpl::GetInstance();
129}
130
131void 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
142PluginServiceImpl* PluginServiceImpl::GetInstance() {
143  return Singleton<PluginServiceImpl>::get();
144}
145
146PluginServiceImpl::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
159PluginServiceImpl::~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
173void 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
195void 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
251PluginProcessHost* 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
261PpapiPluginProcessHost* 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
273PpapiPluginProcessHost* 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
283PluginProcessHost* 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
323PpapiPluginProcessHost* 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
367PpapiPluginProcessHost* 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
391void 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
414void 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
429void 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
443void 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
450void 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
461void 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
489void 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
510bool 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
523bool 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
556bool 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
573base::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
591void 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
615void 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)
629void 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
645void 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
662void 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.
670PepperPluginInfo* 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
698void 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
706void PluginServiceImpl::SetFilter(PluginServiceFilter* filter) {
707  filter_ = filter;
708}
709
710PluginServiceFilter* PluginServiceImpl::GetFilter() {
711  return filter_;
712}
713
714void 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
728static const unsigned int kMaxCrashesPerInterval = 3;
729static const unsigned int kCrashesInterval = 120;
730
731void 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
746bool 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
760void PluginServiceImpl::RefreshPlugins() {
761  PluginList::Singleton()->RefreshPlugins();
762}
763
764void 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
774void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
775  PluginList::Singleton()->RemoveExtraPluginPath(path);
776}
777
778void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) {
779  PluginList::Singleton()->AddExtraPluginDir(path);
780}
781
782void 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
793void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) {
794  PluginList::Singleton()->UnregisterInternalPlugin(path);
795}
796
797void PluginServiceImpl::GetInternalPlugins(
798    std::vector<WebPluginInfo>* plugins) {
799  PluginList::Singleton()->GetInternalPlugins(plugins);
800}
801
802bool PluginServiceImpl::NPAPIPluginsSupported() {
803#if defined(OS_WIN) || defined(OS_MACOSX)
804  return true;
805#else
806  return false;
807#endif
808}
809
810void PluginServiceImpl::DisablePluginsDiscoveryForTesting() {
811  PluginList::Singleton()->DisablePluginsDiscovery();
812}
813
814#if defined(OS_MACOSX)
815void PluginServiceImpl::AppActivated() {
816  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
817                          base::Bind(&NotifyPluginsOfActivation));
818}
819#elif defined(OS_WIN)
820
821bool 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
837bool 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
856bool PluginServiceImpl::IsPluginWindow(HWND window) {
857  return gfx::GetClassName(window) == base::string16(kNativeWindowClassName);
858}
859#endif
860
861bool 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