Rename PluginService to PluginServiceImpl.

content/browser/plugin_service_impl.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 "content/browser/plugin_service_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 20 matching lines @@
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 using ::base::files::FilePathWatcher;
 #endif
 
 using content::BrowserThread;
+using content::PluginService;
 using content::PluginServiceFilter;
 
 namespace {
 
 // Helper function that merely runs the callback with the result. Called on the
 // thread on which the original GetPlugins() call was made.
 static void RunGetPluginsCallback(
     const PluginService::GetPluginsCallback& callback,
     const std::vector<webkit::WebPluginInfo>& result) {
   callback.Run(result);
@@ skipping 49 matching lines @@
     // 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();
+  return PluginServiceImpl::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();
+PluginServiceImpl* PluginServiceImpl::GetInstance() {
+  return Singleton<PluginServiceImpl>::get();
 }
 
-PluginService::PluginService()
+PluginServiceImpl::PluginServiceImpl()
     : plugin_list_(NULL),
       ui_locale_(
           content::GetContentClient()->browser()->GetApplicationLocale()),
       filter_(NULL) {
 }
 
-PluginService::~PluginService() {
+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_.get())
     hkcu_event_->Release();
   if (hklm_event_.get())
     hklm_event_->Release();
 #endif
   // Make sure no plugin channel requests have been leaked.
   DCHECK(pending_plugin_clients_.empty());
 }
 
-void PluginService::Init() {
+void PluginServiceImpl::Init() {
   if (!plugin_list_)
     plugin_list_ = webkit::npapi::PluginList::Singleton();
 
   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())
     AddExtraPluginPath(path);
   path = command_line->GetSwitchValuePath(switches::kExtraPluginDir);
   if (!path.empty())
     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() {
+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) {
     if (hkcu_key_.StartWatching() == ERROR_SUCCESS) {
       hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
       hkcu_watcher_.StartWatching(hkcu_event_.get(), this);
@@ skipping 23 matching lines @@
     // 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();
     VLOG(1) << "Watching for changes in: " << plugin_dirs[i].value();
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        base::Bind(&PluginService::RegisterFilePathWatcher, watcher,
+        base::Bind(&PluginServiceImpl::RegisterFilePathWatcher, watcher,
                    plugin_dirs[i], file_watcher_delegate_));
     file_watchers_.push_back(watcher);
   }
 #endif
 }
 
-const std::string& PluginService::GetUILocale() {
+const std::string& PluginServiceImpl::GetUILocale() {
   return ui_locale_;
 }
 
-PluginProcessHost* PluginService::FindNpapiPluginProcess(
+PluginProcessHost* PluginServiceImpl::FindNpapiPluginProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_PLUGIN);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     if (plugin->info().path == plugin_path)
       return plugin;
   }
 
   return NULL;
 }
 
-PpapiPluginProcessHost* PluginService::FindPpapiPluginProcess(
+PpapiPluginProcessHost* PluginServiceImpl::FindPpapiPluginProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(
            content::PROCESS_TYPE_PPAPI_PLUGIN);
        !iter.Done(); ++iter) {
     PpapiPluginProcessHost* plugin =
         static_cast<PpapiPluginProcessHost*>(*iter);
     if (plugin->plugin_path() == plugin_path)
       return plugin;
   }
 
   return NULL;
 }
 
-PpapiPluginProcessHost* PluginService::FindPpapiBrokerProcess(
+PpapiPluginProcessHost* PluginServiceImpl::FindPpapiBrokerProcess(
     const FilePath& broker_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(
            content::PROCESS_TYPE_PPAPI_BROKER);
        !iter.Done(); ++iter) {
     PpapiPluginProcessHost* broker =
         static_cast<PpapiPluginProcessHost*>(*iter);
     if (broker->plugin_path() == broker_path)
       return broker;
   }
 
   return NULL;
 }
 
-PluginProcessHost* PluginService::FindOrStartNpapiPluginProcess(
+PluginProcessHost* PluginServiceImpl::FindOrStartNpapiPluginProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   webkit::WebPluginInfo info;
   if (!GetPluginInfoByPath(plugin_path, &info)) {
     return NULL;
   }
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost());
   if (!new_host->Init(info, ui_locale_)) {
     NOTREACHED();  // Init is not expected to fail.
     return NULL;
   }
   return new_host.release();
 }
 
-PpapiPluginProcessHost* PluginService::FindOrStartPpapiPluginProcess(
+PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiPluginProcess(
     const FilePath& plugin_path,
     PpapiPluginProcessHost::PluginClient* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PpapiPluginProcessHost* plugin_host = FindPpapiPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   // Validate that the plugin is actually registered.
   content::PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
   if (!info)
     return NULL;
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   return PpapiPluginProcessHost::CreatePluginHost(
       *info,
       client->GetResourceContext()->host_resolver());
 }
 
-PpapiPluginProcessHost* PluginService::FindOrStartPpapiBrokerProcess(
+PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiBrokerProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PpapiPluginProcessHost* plugin_host = FindPpapiBrokerProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   // Validate that the plugin is actually registered.
   content::PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
   if (!info)
     return NULL;
 
   // TODO(ddorwin): Uncomment once out of process is supported.
   // DCHECK(info->is_out_of_process);
 
   // This broker isn't loaded by any broker process, so create a new process.
   return PpapiPluginProcessHost::CreateBrokerHost(*info);
 }
 
-void PluginService::OpenChannelToNpapiPlugin(
+void PluginServiceImpl::OpenChannelToNpapiPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.insert(client);
 
   // Make sure plugins are loaded if necessary.
   content::PluginServiceFilterParams params = {
     render_process_id,
     render_view_id,
     page_url,
     &client->GetResourceContext()
   };
-  GetPlugins(
-      base::Bind(&PluginService::ForwardGetAllowedPluginForOpenChannelToPlugin,
-                 base::Unretained(this), params, url, mime_type, client));
+  GetPlugins(base::Bind(
+      &PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin,
+      base::Unretained(this), params, url, mime_type, client));
 }
 
-void PluginService::OpenChannelToPpapiPlugin(
+void PluginServiceImpl::OpenChannelToPpapiPlugin(
     const FilePath& path,
     PpapiPluginProcessHost::PluginClient* client) {
   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess(
       path, client);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else  // Send error.
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
-void PluginService::OpenChannelToPpapiBroker(
+void PluginServiceImpl::OpenChannelToPpapiBroker(
     const FilePath& path,
     PpapiPluginProcessHost::BrokerClient* client) {
   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiBrokerProcess(path);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else  // Send error.
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
-void PluginService::CancelOpenChannelToNpapiPlugin(
+void PluginServiceImpl::CancelOpenChannelToNpapiPlugin(
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.erase(client);
 }
 
-void PluginService::ForwardGetAllowedPluginForOpenChannelToPlugin(
+void PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin(
     const content::PluginServiceFilterParams& params,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     const std::vector<webkit::WebPluginInfo>&) {
   GetAllowedPluginForOpenChannelToPlugin(params.render_process_id,
       params.render_view_id, url, params.page_url, mime_type, client,
       params.resource_context);
 }
 
-void PluginService::GetAllowedPluginForOpenChannelToPlugin(
+void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     const content::ResourceContext* resource_context) {
   webkit::WebPluginInfo info;
   bool allow_wildcard = true;
   bool found = GetPluginInfo(
       render_process_id, render_view_id, *resource_context,
       url, page_url, mime_type, allow_wildcard,
       NULL, &info, NULL);
   FilePath plugin_path;
   if (found)
     plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&PluginService::FinishOpenChannelToPlugin,
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&PluginServiceImpl::FinishOpenChannelToPlugin,
                  base::Unretained(this), plugin_path, client));
 }
 
-void PluginService::FinishOpenChannelToPlugin(
+void PluginServiceImpl::FinishOpenChannelToPlugin(
     const FilePath& plugin_path,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Make sure it hasn't been canceled yet.
   if (!ContainsKey(pending_plugin_clients_, client))
     return;
   pending_plugin_clients_.erase(client);
 
   PluginProcessHost* plugin_host = FindOrStartNpapiPluginProcess(plugin_path);
   if (plugin_host) {
     client->OnFoundPluginProcessHost(plugin_host);
     plugin_host->OpenChannelToPlugin(client);
   } else {
     client->OnError();
   }
 }
 
-bool PluginService::GetPluginInfoArray(
+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);
   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,
-                                  bool* is_stale,
-                                  webkit::WebPluginInfo* info,
-                                  std::string* actual_mime_type) {
+bool PluginServiceImpl::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,
+                                      bool* is_stale,
+                                      webkit::WebPluginInfo* info,
+                                      std::string* actual_mime_type) {
   std::vector<webkit::WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
   bool stale = GetPluginInfoArray(
       url, mime_type, allow_wildcard, &plugins, &mime_types);
   if (is_stale)
     *is_stale = stale;
   if (plugins.size() > 1 &&
       plugins.back().path ==
           FilePath(webkit::npapi::kDefaultPluginLibraryName)) {
     // If there is at least one plug-in handling the required MIME type (apart
@@ skipping 10 matching lines @@
                                              &plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
-bool PluginService::GetPluginInfoByPath(const FilePath& plugin_path,
-                                        webkit::WebPluginInfo* info) {
+bool PluginServiceImpl::GetPluginInfoByPath(const FilePath& plugin_path,
+                                            webkit::WebPluginInfo* info) {
   std::vector<webkit::WebPluginInfo> 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) {
+void PluginServiceImpl::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),
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&PluginServiceImpl::GetPluginsInternal, base::Unretained(this),
           target_loop, callback));
 #else
   std::vector<webkit::WebPluginInfo> 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) {
+void PluginServiceImpl::GetPluginGroups(
+    const GetPluginGroupsCallback& callback) {
   GetPlugins(base::Bind(&GetPluginsForGroupsCallback, callback));
 }
 
-void PluginService::GetPluginsInternal(
+void PluginServiceImpl::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<webkit::WebPluginInfo> plugins;
   plugin_list_->GetPlugins(&plugins);
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(&RunGetPluginsCallback, callback, plugins));
 }
 
-void PluginService::OnWaitableEventSignaled(
+void PluginServiceImpl::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();
   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) {
+void PluginServiceImpl::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::RegisterPepperPlugins() {
+void PluginServiceImpl::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(
+content::PepperPluginInfo* PluginServiceImpl::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];
       break;
     }
   }
   if (info)
     return info;
   // We did not find the plugin in our list. But wait! the plugin can also
   // be a latecomer, as it happens with pepper flash. This information
   // can be obtained from the PluginList singleton and we can use it to
   // construct it and add it to the list. This same deal needs to be done
   // in the renderer side in PepperPluginRegistry.
   webkit::WebPluginInfo webplugin_info;
   if (!GetPluginInfoByPath(plugin_path, &webplugin_info))
     return NULL;
   content::PepperPluginInfo new_pepper_info;
   if (!MakePepperPluginInfo(webplugin_info, &new_pepper_info))
     return NULL;
   ppapi_plugins_.push_back(new_pepper_info);
   return &ppapi_plugins_[ppapi_plugins_.size() - 1];
 }
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 // static
-void PluginService::RegisterFilePathWatcher(
+void PluginServiceImpl::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif
 
-void PluginService::SetFilter(content::PluginServiceFilter* filter) {
+void PluginServiceImpl::SetFilter(content::PluginServiceFilter* filter) {
   filter_ = filter;
 }
 
-content::PluginServiceFilter* PluginService::GetFilter() {
+content::PluginServiceFilter* PluginServiceImpl::GetFilter() {
   return filter_;
 }
 
-void PluginService::RefreshPlugins() {
+void PluginServiceImpl::RefreshPlugins() {
   plugin_list_->RefreshPlugins();
 }
 
-void PluginService::AddExtraPluginPath(const FilePath& path) {
+void PluginServiceImpl::AddExtraPluginPath(const FilePath& path) {
   plugin_list_->AddExtraPluginPath(path);
 }
 
-void PluginService::RemoveExtraPluginPath(const FilePath& path) {
+void PluginServiceImpl::RemoveExtraPluginPath(const FilePath& path) {
   plugin_list_->RemoveExtraPluginPath(path);
 }
 
-void PluginService::UnregisterInternalPlugin(const FilePath& path) {
+void PluginServiceImpl::UnregisterInternalPlugin(const FilePath& path) {
   plugin_list_->UnregisterInternalPlugin(path);
 }
 
-void PluginService::SetPluginListForTesting(
+void PluginServiceImpl::SetPluginListForTesting(
     webkit::npapi::PluginList* plugin_list) {
   plugin_list_ = plugin_list;
 }
 
-void PluginService::RegisterInternalPlugin(const webkit::WebPluginInfo& info) {
+void PluginServiceImpl::RegisterInternalPlugin(
+    const webkit::WebPluginInfo& info) {
   plugin_list_->RegisterInternalPlugin(info);
 }
 
-string16 PluginService::GetPluginGroupName(const std::string& plugin_name) {
+string16 PluginServiceImpl::GetPluginGroupName(const std::string& plugin_name) {
   return plugin_list_->GetPluginGroupName(plugin_name);
 }
 
-webkit::npapi::PluginList* PluginService::GetPluginList() {
+webkit::npapi::PluginList* PluginServiceImpl::GetPluginList() {
   return plugin_list_;
 }