Move NPAPI implementation out of webkit/plugins/npapi and into 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"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/browser/ppapi_plugin_process_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/pepper_plugin_registry.h"
+#include "content/common/plugin_list.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/plugin_service_filter.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
-#include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/plugin_utils.h"
 #include "webkit/plugins/plugin_constants.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_WIN)
-#include "webkit/plugins/npapi/plugin_constants_win.h"
+#include "content/common/plugin_constants_win.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "content/browser/plugin_loader_posix.h"
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
 using ::base::FilePathWatcher;
 #endif
 
@@ skipping 53 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
 void NotifyPluginDirChanged(const base::FilePath& path, bool error) {
   if (error) {
     // TODO(pastarmovj): Add some sensible error handling. Maybe silently
     // stopping the watcher would be enough. Or possibly restart it.
     NOTREACHED();
     return;
   }
   VLOG(1) << "Watched path changed: " << path.value();
   // Make the plugin list update itself
-  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
+  PluginList::Singleton()->RefreshPlugins();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PluginService::PurgePluginListCache,
                  static_cast<BrowserContext*>(NULL), false));
 }
 #endif
 
 }  // namespace
 
 // static
@@ skipping 38 matching lines @@
     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() {
   plugin_list_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();
-  webkit::npapi::PluginList::Singleton()->set_will_load_plugins_callback(
+  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())
-    webkit::npapi::PluginList::Singleton()->AddExtraPluginDir(path);
+    PluginList::Singleton()->AddExtraPluginDir(path);
 
   if (command_line->HasSwitch(switches::kDisablePluginsDiscovery))
-    webkit::npapi::PluginList::Singleton()->DisablePluginsDiscovery();
+    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,
+                       kRegistryMozillaPlugins,
                        KEY_NOTIFY) == ERROR_SUCCESS) {
     if (hkcu_key_.StartWatching() == ERROR_SUCCESS) {
       hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
       base::WaitableEventWatcher::EventCallback callback =
             base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
                        base::Unretained(this));
       hkcu_watcher_.StartWatching(hkcu_event_.get(), callback);
     }
   }
   if (hklm_key_.Create(HKEY_LOCAL_MACHINE,
-                       webkit::npapi::kRegistryMozillaPlugins,
+                       kRegistryMozillaPlugins,
                        KEY_NOTIFY) == ERROR_SUCCESS) {
     if (hklm_key_.StartWatching() == ERROR_SUCCESS) {
       hklm_event_.reset(new base::WaitableEvent(hklm_key_.watch_event()));
       base::WaitableEventWatcher::EventCallback callback =
             base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
                        base::Unretained(this));
       hklm_watcher_.StartWatching(hklm_event_.get(), callback);
     }
   }
 #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;
-  webkit::npapi::PluginList::Singleton()->GetPluginDirectories(&plugin_dirs);
+  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;
-  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
+  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,
@@ skipping 20 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;
-  webkit::npapi::PluginList::Singleton()->GetPluginsNoRefresh(&plugins);
+  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 (webkit::npapi::PluginList::Singleton()->GetPluginsNoRefresh(
-          &cached_plugins)) {
+  if (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;
-  webkit::npapi::PluginList::Singleton()->GetPlugins(&plugins);
+  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();
   }
 
-  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
+  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() {
-  webkit::npapi::PluginList::Singleton()->RefreshPlugins();
+  PluginList::Singleton()->RefreshPlugins();
 }
 
 void PluginServiceImpl::AddExtraPluginPath(const base::FilePath& path) {
-  webkit::npapi::PluginList::Singleton()->AddExtraPluginPath(path);
+  PluginList::Singleton()->AddExtraPluginPath(path);
 }
 
 void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
-  webkit::npapi::PluginList::Singleton()->RemoveExtraPluginPath(path);
+  PluginList::Singleton()->RemoveExtraPluginPath(path);
 }
 
 void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) {
-  webkit::npapi::PluginList::Singleton()->AddExtraPluginDir(path);
+  PluginList::Singleton()->AddExtraPluginDir(path);
 }
 
 void PluginServiceImpl::RegisterInternalPlugin(
     const webkit::WebPluginInfo& info,
     bool add_at_beginning) {
-  webkit::npapi::PluginList::Singleton()->RegisterInternalPlugin(
-      info, add_at_beginning);
+  PluginList::Singleton()->RegisterInternalPlugin(info, add_at_beginning);
 }
 
 void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) {
-  webkit::npapi::PluginList::Singleton()->UnregisterInternalPlugin(path);
+  PluginList::Singleton()->UnregisterInternalPlugin(path);
 }
 
 void PluginServiceImpl::GetInternalPlugins(
     std::vector<webkit::WebPluginInfo>* plugins) {
-  webkit::npapi::PluginList::Singleton()->GetInternalPlugins(plugins);
+  PluginList::Singleton()->GetInternalPlugins(plugins);
 }
 
 void PluginServiceImpl::DisablePluginsDiscoveryForTesting() {
-  webkit::npapi::PluginList::Singleton()->DisablePluginsDiscovery();
+  PluginList::Singleton()->DisablePluginsDiscovery();
 }
 
 #if defined(OS_MACOSX)
 void PluginServiceImpl::AppActivated() {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&NotifyPluginsOfActivation));
 }
 #endif
 
 }  // namespace content