Remove plugin_list.h includes from chrome tests in preparation for moving webkit/plugins to content…

content/browser/plugin_service_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 120 matching lines @@
       host->Send(new ViewMsg_PurgePluginListCache(reload_pages));
   }
 }
 
 // static
 PluginServiceImpl* PluginServiceImpl::GetInstance() {
   return Singleton<PluginServiceImpl>::get();
 }
 
 PluginServiceImpl::PluginServiceImpl()
-    : plugin_list_(NULL), filter_(NULL) {
+    : filter_(NULL) {
   // Collect the total number of browser processes (which create
   // PluginServiceImpl objects, to be precise). The number is used to normalize
   // the number of processes which start at least one NPAPI/PPAPI Flash process.
   static bool counted = false;
   if (!counted) {
     counted = true;
     UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage", TOTAL_BROWSER_PROCESSES,
                               FLASH_USAGE_ENUM_COUNT);
   }
 }
 
 PluginServiceImpl::~PluginServiceImpl() {
 #if defined(OS_WIN)
   // Release the events since they're owned by RegKey, not WaitableEvent.
   hkcu_watcher_.StopWatching();
   hklm_watcher_.StopWatching();
   if (hkcu_event_)
     hkcu_event_->Release();
   if (hklm_event_)
     hklm_event_->Release();
 #endif
   // Make sure no plugin channel requests have been leaked.
   DCHECK(pending_plugin_clients_.empty());
 }
 
 void PluginServiceImpl::Init() {
-  if (!plugin_list_)
-    plugin_list_ = webkit::npapi::PluginList::Singleton();
-
   plugin_list_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();
-  plugin_list_->set_will_load_plugins_callback(
+  webkit::npapi::PluginList::Singleton()->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallback, plugin_list_token_));
 
   RegisterPepperPlugins();
 
   // The --site-per-process flag enables an out-of-process iframes
   // prototype, which uses WebView for rendering. We need to register the MIME
   // type we use with the plugin, so the renderer can instantiate it.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kSitePerProcess)) {
     webkit::WebPluginInfo webview_plugin(
         ASCIIToUTF16("WebView Tag"),
         base::FilePath(),
         ASCIIToUTF16("1.2.3.4"),
         ASCIIToUTF16("Browser Plugin."));
     webview_plugin.type = webkit::WebPluginInfo::PLUGIN_TYPE_NPAPI;
     webkit::WebPluginMimeType webview_plugin_mime_type;
     webview_plugin_mime_type.mime_type = "application/browser-plugin";
     webview_plugin_mime_type.file_extensions.push_back("*");
     webview_plugin.mime_types.push_back(webview_plugin_mime_type);
     RegisterInternalPlugin(webview_plugin, true);
   }
 
   // Load any specified on the command line as well.
   base::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);
+    webkit::npapi::PluginList::Singleton()->AddExtraPluginDir(path);
 
   if (command_line->HasSwitch(switches::kDisablePluginsDiscovery))
-    plugin_list_->DisablePluginsDiscovery();
+    webkit::npapi::PluginList::Singleton()->DisablePluginsDiscovery();
 }
 
 void PluginServiceImpl::StartWatchingPlugins() {
   // Start watching for changes in the plugin list. This means watching
   // for changes in the Windows registry keys and on both Windows and POSIX
   // watch for changes in the paths that are expected to contain plugins.
 #if defined(OS_WIN)
   if (hkcu_key_.Create(HKEY_CURRENT_USER,
                        webkit::npapi::kRegistryMozillaPlugins,
                        KEY_NOTIFY) == ERROR_SUCCESS) {
@@ skipping 17 matching lines @@
     }
   }
 #endif
 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
 // 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.
 
   // 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<base::FilePath> plugin_dirs;
-  plugin_list_->GetPluginDirectories(&plugin_dirs);
+  webkit::npapi::PluginList::Singleton()->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 252 matching lines @@
   }
 }
 
 bool PluginServiceImpl::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);
+  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
+      url, mime_type, allow_wildcard, &use_stale, plugins, actual_mime_types);
   return use_stale;
 }
 
 bool PluginServiceImpl::GetPluginInfo(int render_process_id,
                                       int render_view_id,
                                       ResourceContext* context,
                                       const GURL& url,
                                       const GURL& page_url,
                                       const std::string& mime_type,
                                       bool allow_wildcard,
@@ skipping 19 matching lines @@
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
 bool PluginServiceImpl::GetPluginInfoByPath(const base::FilePath& plugin_path,
                                             webkit::WebPluginInfo* info) {
   std::vector<webkit::WebPluginInfo> plugins;
-  plugin_list_->GetPluginsNoRefresh(&plugins);
+  webkit::npapi::PluginList::Singleton()->GetPluginsNoRefresh(&plugins);
 
   for (std::vector<webkit::WebPluginInfo>::iterator it = plugins.begin();
        it != plugins.end();
        ++it) {
     if (it->path == plugin_path) {
       *info = *it;
       return true;
     }
   }
 
@@ skipping 28 matching lines @@
             plugin_list_token_,
             FROM_HERE,
             base::Bind(&PluginServiceImpl::GetPluginsInternal,
                        base::Unretained(this),
                        target_loop, callback),
         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
     return;
   }
 #if defined(OS_POSIX)
   std::vector<webkit::WebPluginInfo> cached_plugins;
-  if (plugin_list_->GetPluginsNoRefresh(&cached_plugins)) {
+  if (webkit::npapi::PluginList::Singleton()->GetPluginsNoRefresh(
+          &cached_plugins)) {
     // Can't assume the caller is reentrant.
     target_loop->PostTask(FROM_HERE,
         base::Bind(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));
   }
 #else
   NOTREACHED();
 #endif
 }
 
 void PluginServiceImpl::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       plugin_list_token_));
 
   std::vector<webkit::WebPluginInfo> plugins;
-  plugin_list_->GetPlugins(&plugins);
+  webkit::npapi::PluginList::Singleton()->GetPlugins(&plugins);
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(callback, plugins));
 }
 
 void PluginServiceImpl::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
-  plugin_list_->RefreshPlugins();
+  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
   PurgePluginListCache(NULL, false);
 #else
   // This event should only get signaled on a Windows machine.
   NOTREACHED();
 #endif  // defined(OS_WIN)
 }
 
 void PluginServiceImpl::RegisterPepperPlugins() {
   // TODO(abarth): It seems like the PepperPluginRegistry should do this work.
   PepperPluginRegistry::ComputeList(&ppapi_plugins_);
@@ skipping 87 matching lines @@
     return false;
   }
   if (i->second.size() != kMaxCrashesPerInterval) {
     return false;
   }
   base::TimeDelta delta = base::Time::Now() - i->second[0];
   return delta.InSeconds() <= kCrashesInterval;
 }
 
 void PluginServiceImpl::RefreshPlugins() {
-  plugin_list_->RefreshPlugins();
+  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
 }
 
 void PluginServiceImpl::AddExtraPluginPath(const base::FilePath& path) {
-  plugin_list_->AddExtraPluginPath(path);
+  webkit::npapi::PluginList::Singleton()->AddExtraPluginPath(path);
+}
+
+void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
+  webkit::npapi::PluginList::Singleton()->RemoveExtraPluginPath(path);
 }
 
 void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) {
-  plugin_list_->AddExtraPluginDir(path);
+  webkit::npapi::PluginList::Singleton()->AddExtraPluginDir(path);
 }
 
-void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
-  plugin_list_->RemoveExtraPluginPath(path);
+void PluginServiceImpl::RegisterInternalPlugin(
+    const webkit::WebPluginInfo& info,
+    bool add_at_beginning) {
+  webkit::npapi::PluginList::Singleton()->RegisterInternalPlugin(
+      info, add_at_beginning);
 }
 
 void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) {
-  plugin_list_->UnregisterInternalPlugin(path);
+  webkit::npapi::PluginList::Singleton()->UnregisterInternalPlugin(path);
 }
 
-void PluginServiceImpl::SetPluginListForTesting(
-    webkit::npapi::PluginList* plugin_list) {
-  plugin_list_ = plugin_list;
+void PluginServiceImpl::GetInternalPlugins(
+    std::vector<webkit::WebPluginInfo>* plugins) {
+  webkit::npapi::PluginList::Singleton()->GetInternalPlugins(plugins);
+}
+
+void PluginServiceImpl::DisablePluginsDiscoveryForTesting() {
+  webkit::npapi::PluginList::Singleton()->DisablePluginsDiscovery();
 }
 
 #if defined(OS_MACOSX)
 void PluginServiceImpl::AppActivated() {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&NotifyPluginsOfActivation));
 }
 #endif
 
-void PluginServiceImpl::RegisterInternalPlugin(
-    const webkit::WebPluginInfo& info,
-    bool add_at_beginning) {
-  plugin_list_->RegisterInternalPlugin(info, add_at_beginning);
-}
-
-void PluginServiceImpl::GetInternalPlugins(
-    std::vector<webkit::WebPluginInfo>* plugins) {
-  plugin_list_->GetInternalPlugins(plugins);
-}
-
 }  // namespace content