Revert r108760 / reland r108744, r108753 w/ fix

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 98 matching lines @@
 
 // static
 PluginService* PluginService::GetInstance() {
   return Singleton<PluginService>::get();
 }
 
 PluginService::PluginService()
     : ui_locale_(
           content::GetContentClient()->browser()->GetApplicationLocale()),
       filter_(NULL) {
-  webkit::npapi::PluginList::Singleton()->set_will_load_plugins_callback(
+  plugin_list()->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallback));
 
   RegisterPepperPlugins();
 
+  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())
-    webkit::npapi::PluginList::Singleton()->AddExtraPluginPath(path);
+    AddExtraPluginPath(path);
   path = command_line->GetSwitchValuePath(switches::kExtraPluginDir);
   if (!path.empty())
-    webkit::npapi::PluginList::Singleton()->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
 }
 
 PluginService::~PluginService() {
@@ skipping 33 matching lines @@
   }
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
 // 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;
-  webkit::npapi::PluginList::Singleton()->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;
-  webkit::npapi::PluginList::Singleton()->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;
-  webkit::npapi::PluginList::Singleton()->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::RefreshPluginList() {
-  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
-}
-
 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 (webkit::npapi::PluginList::Singleton()->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;
-  webkit::npapi::PluginList::Singleton()->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();
   }
 
-  webkit::npapi::PluginList::Singleton()->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) {
@@ skipping 15 matching lines @@
     RenderProcessHost* host = it.GetCurrentValue();
     if (!browser_context || host->browser_context() == 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) {
-    webkit::npapi::PluginList::Singleton()->RegisterInternalPlugin(
-        ppapi_plugins_[i].ToWebPluginInfo());
+    RegisterInternalPlugin(ppapi_plugins_[i].ToWebPluginInfo());
   }
 }
 
 // There should generally be very few plugins so a brute-force search is fine.
 content::PepperPluginInfo* PluginService::GetRegisteredPpapiPluginInfo(
     const FilePath& plugin_path) {
   content::PepperPluginInfo* info = NULL;
   for (size_t i = 0; i < ppapi_plugins_.size(); i++) {
     if (ppapi_plugins_[i].path == plugin_path) {
       info = &ppapi_plugins_[i];
@@ skipping 20 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif
+
+void PluginService::RefreshPlugins() {
+  plugin_list()->RefreshPlugins();
+}
+
+void PluginService::AddExtraPluginPath(const FilePath& path) {
+  plugin_list()->AddExtraPluginPath(path);
+}
+
+void PluginService::RemoveExtraPluginPath(const FilePath& path) {
+  plugin_list()->RemoveExtraPluginPath(path);
+}
+
+void PluginService::UnregisterInternalPlugin(const FilePath& path) {
+  plugin_list()->UnregisterInternalPlugin(path);
+}
+
+webkit::npapi::PluginList* PluginService::plugin_list() {
+  return webkit::npapi::PluginList::Singleton();
+}
+
+void PluginService::RegisterInternalPlugin(const webkit::WebPluginInfo& info) {
+  plugin_list()->RegisterInternalPlugin(info);
+}
+
+string16 PluginService::GetPluginGroupName(const std::string& plugin_name) {
+  return plugin_list()->GetPluginGroupName(plugin_name);
+}