Create an API around PluginService and use it from Chrome.

content/browser/plugin_service.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/plugin_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 79 matching lines @@
 }
 #elif defined(OS_POSIX) && !defined(OS_OPENBSD)
 // Delegate class for monitoring directories.
 class PluginDirWatcherDelegate : public FilePathWatcher::Delegate {
   virtual void OnFilePathChanged(const FilePath& path) OVERRIDE {
     VLOG(1) << "Watched path changed: " << path.value();
     // Make the plugin list update itself
     webkit::npapi::PluginList::Singleton()->RefreshPlugins();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&PluginService::PurgePluginListCache,
+        base::Bind(&content::PluginService::PurgePluginListCache,
                    static_cast<content::BrowserContext*>(NULL), false));
   }
 
   virtual void OnFilePathError(const FilePath& path) OVERRIDE {
     // TODO(pastarmovj): Add some sensible error handling. Maybe silently
     // stopping the watcher would be enough. Or possibly restart it.
     NOTREACHED();
   }
 };
 #endif
 
+namespace content {
+// static
+PluginService* PluginService::GetInstance() {
+  return ::PluginService::GetInstance();
+}
+
+void PluginService::PurgePluginListCache(BrowserContext* browser_context,
+                                         bool reload_pages) {
+  for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
+       !it.IsAtEnd(); it.Advance()) {
+    RenderProcessHost* host = it.GetCurrentValue();
+    if (!browser_context || host->GetBrowserContext() == browser_context)
+      host->Send(new ViewMsg_PurgePluginListCache(reload_pages));
+  }
+}
+
+}  // namespace content
+
 // static
 PluginService* PluginService::GetInstance() {
   return Singleton<PluginService>::get();
 }
 
 PluginService::PluginService()
     : plugin_list_(NULL),
       ui_locale_(
           content::GetContentClient()->browser()->GetApplicationLocale()),
       filter_(NULL) {
@@ skipping 10 matching lines @@
     hklm_event_->Release();
 #endif
   // Make sure no plugin channel requests have been leaked.
   DCHECK(pending_plugin_clients_.empty());
 }
 
 void PluginService::Init() {
   if (!plugin_list_)
     plugin_list_ = webkit::npapi::PluginList::Singleton();
 
-  plugin_list()->set_will_load_plugins_callback(
+  plugin_list_->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallback));
 
   RegisterPepperPlugins();
 
-  content::GetContentClient()->AddNPAPIPlugins(plugin_list());
+  content::GetContentClient()->AddNPAPIPlugins(plugin_list_);
 
   // Load any specified on the command line as well.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   FilePath path = command_line->GetSwitchValuePath(switches::kLoadPlugin);
   if (!path.empty())
     AddExtraPluginPath(path);
   path = command_line->GetSwitchValuePath(switches::kExtraPluginDir);
   if (!path.empty())
-    plugin_list()->AddExtraPluginDir(path);
+    plugin_list_->AddExtraPluginDir(path);
 
 #if defined(OS_MACOSX)
   // We need to know when the browser comes forward so we can bring modal plugin
   // windows forward too.
   registrar_.Add(this, content::NOTIFICATION_APP_ACTIVATED,
                  content::NotificationService::AllSources());
 #endif
 }
 
 void PluginService::StartWatchingPlugins() {
@@ skipping 19 matching lines @@
   }
 #elif defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 // The FilePathWatcher produces too many false positives on MacOS (access time
 // updates?) which will lead to enforcing updates of the plugins way too often.
 // On ChromeOS the user can't install plugins anyway and on Windows all
 // important plugins register themselves in the registry so no need to do that.
   file_watcher_delegate_ = new PluginDirWatcherDelegate();
   // Get the list of all paths for registering the FilePathWatchers
   // that will track and if needed reload the list of plugins on runtime.
   std::vector<FilePath> plugin_dirs;
-  plugin_list()->GetPluginDirectories(&plugin_dirs);
+  plugin_list_->GetPluginDirectories(&plugin_dirs);
 
   for (size_t i = 0; i < plugin_dirs.size(); ++i) {
     // FilePathWatcher can not handle non-absolute paths under windows.
     // We don't watch for file changes in windows now but if this should ever
     // be extended to Windows these lines might save some time of debugging.
 #if defined(OS_WIN)
     if (!plugin_dirs[i].IsAbsolute())
       continue;
 #endif
     FilePathWatcher* watcher = new FilePathWatcher();
@@ skipping 224 matching lines @@
   }
 }
 
 bool PluginService::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     std::vector<webkit::WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   bool use_stale = false;
-  plugin_list()->GetPluginInfoArray(url, mime_type, allow_wildcard,
-                                    &use_stale, plugins, actual_mime_types);
+  plugin_list_->GetPluginInfoArray(url, mime_type, allow_wildcard,
+                                   &use_stale, plugins, actual_mime_types);
   return use_stale;
 }
 
 bool PluginService::GetPluginInfo(int render_process_id,
                                   int render_view_id,
                                   const content::ResourceContext& context,
                                   const GURL& url,
                                   const GURL& page_url,
                                   const std::string& mime_type,
                                   bool allow_wildcard,
@@ skipping 26 matching lines @@
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
 bool PluginService::GetPluginInfoByPath(const FilePath& plugin_path,
                                         webkit::WebPluginInfo* info) {
   std::vector<webkit::WebPluginInfo> plugins;
-  plugin_list()->GetPluginsIfNoRefreshNeeded(&plugins);
+  plugin_list_->GetPluginsIfNoRefreshNeeded(&plugins);
 
   for (std::vector<webkit::WebPluginInfo>::iterator it = plugins.begin();
        it != plugins.end();
        ++it) {
     if (it->path == plugin_path) {
       *info = *it;
       return true;
     }
   }
 
   return false;
 }
 
 void PluginService::GetPlugins(const GetPluginsCallback& callback) {
   scoped_refptr<base::MessageLoopProxy> target_loop(
       MessageLoop::current()->message_loop_proxy());
 
 #if defined(OS_WIN)
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(&PluginService::GetPluginsInternal, base::Unretained(this),
           target_loop, callback));
 #else
   std::vector<webkit::WebPluginInfo> cached_plugins;
-  if (plugin_list()->GetPluginsIfNoRefreshNeeded(&cached_plugins)) {
+  if (plugin_list_->GetPluginsIfNoRefreshNeeded(&cached_plugins)) {
     // Can't assume the caller is reentrant.
     target_loop->PostTask(FROM_HERE,
         base::Bind(&RunGetPluginsCallback, callback, cached_plugins));
   } else {
     // If we switch back to loading plugins in process, then we need to make
     // sure g_thread_init() gets called since plugins may call glib at load.
     if (!plugin_loader_.get())
       plugin_loader_ = new PluginLoaderPosix;
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&PluginLoaderPosix::LoadPlugins, plugin_loader_,
                    target_loop, callback));
   }
 #endif
 }
 
 void PluginService::GetPluginGroups(const GetPluginGroupsCallback& callback) {
   GetPlugins(base::Bind(&GetPluginsForGroupsCallback, callback));
 }
 
 void PluginService::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<webkit::WebPluginInfo> plugins;
-  plugin_list()->GetPlugins(&plugins);
+  plugin_list_->GetPlugins(&plugins);
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(&RunGetPluginsCallback, callback, plugins));
 }
 
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
-  plugin_list()->RefreshPlugins();
+  plugin_list_->RefreshPlugins();
   PurgePluginListCache(NULL, false);
 #else
   // This event should only get signaled on a Windows machine.
   NOTREACHED();
 #endif  // defined(OS_WIN)
 }
 
 void PluginService::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
 #if defined(OS_MACOSX)
   if (type == content::NOTIFICATION_APP_ACTIVATED) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&NotifyPluginsOfActivation));
     return;
   }
 #endif
   NOTREACHED();
 }
 
-void PluginService::PurgePluginListCache(
-    content::BrowserContext* browser_context,
-    bool reload_pages) {
-  for (content::RenderProcessHost::iterator it =
-          content::RenderProcessHost::AllHostsIterator();
-       !it.IsAtEnd(); it.Advance()) {
-    content::RenderProcessHost* host = it.GetCurrentValue();
-    if (!browser_context || host->GetBrowserContext() == browser_context)
-      host->Send(new ViewMsg_PurgePluginListCache(reload_pages));
-  }
-}
-
 void PluginService::RegisterPepperPlugins() {
   // TODO(abarth): It seems like the PepperPluginRegistry should do this work.
   PepperPluginRegistry::ComputeList(&ppapi_plugins_);
   for (size_t i = 0; i < ppapi_plugins_.size(); ++i) {
     RegisterInternalPlugin(ppapi_plugins_[i].ToWebPluginInfo());
   }
 }
 
 // There should generally be very few plugins so a brute-force search is fine.
 content::PepperPluginInfo* PluginService::GetRegisteredPpapiPluginInfo(
@@ skipping 26 matching lines @@
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif
 
+void PluginService::SetFilter(content::PluginServiceFilter* filter) {
+  filter_ = filter;
+}
+
+content::PluginServiceFilter* PluginService::GetFilter() {
+  return filter_;
+}
+
 void PluginService::RefreshPlugins() {
-  plugin_list()->RefreshPlugins();
+  plugin_list_->RefreshPlugins();
 }
 
 void PluginService::AddExtraPluginPath(const FilePath& path) {
-  plugin_list()->AddExtraPluginPath(path);
+  plugin_list_->AddExtraPluginPath(path);
 }
 
 void PluginService::RemoveExtraPluginPath(const FilePath& path) {
-  plugin_list()->RemoveExtraPluginPath(path);
+  plugin_list_->RemoveExtraPluginPath(path);
 }
 
 void PluginService::UnregisterInternalPlugin(const FilePath& path) {
-  plugin_list()->UnregisterInternalPlugin(path);
+  plugin_list_->UnregisterInternalPlugin(path);
 }
 
 void PluginService::SetPluginListForTesting(
     webkit::npapi::PluginList* plugin_list) {
   plugin_list_ = plugin_list;
 }
 
 void PluginService::RegisterInternalPlugin(const webkit::WebPluginInfo& info) {
-  plugin_list()->RegisterInternalPlugin(info);
+  plugin_list_->RegisterInternalPlugin(info);
 }
 
 string16 PluginService::GetPluginGroupName(const std::string& plugin_name) {
-  return plugin_list()->GetPluginGroupName(plugin_name);
+  return plugin_list_->GetPluginGroupName(plugin_name);
 }
+
+webkit::npapi::PluginList* PluginService::GetPluginList() {
+  return plugin_list_;
+}