Move the remaning files in content\common to the content namespace.

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/file_path.h"
@@ skipping 26 matching lines @@
 #endif
 
 #if defined(OS_POSIX)
 #include "content/browser/plugin_loader_posix.h"
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_OPENBSD)
 using ::base::files::FilePathWatcher;
 #endif
 
-using content::BrowserThread;
-using content::PepperPluginRegistry;
-using content::PluginService;
-using content::PluginServiceFilter;
-
+namespace content {
 namespace {
 
 // Callback set on the PluginList to assert that plugin loading happens on the
 // correct thread.
 #if defined(OS_WIN)
 void WillLoadPluginsCallbackWin(
     base::SequencedWorkerPool::SequenceToken token) {
   CHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       token));
 }
@@ skipping 15 matching lines @@
 #endif
 #if 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(&content::PluginService::PurgePluginListCache,
-                   static_cast<content::BrowserContext*>(NULL), false));
+        base::Bind(&PluginService::PurgePluginListCache,
+                   static_cast<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();
   }
 
  protected:
   virtual ~PluginDirWatcherDelegate() {}
 };
 #endif
 
-namespace content {
 // static
 PluginService* 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
 PluginServiceImpl* PluginServiceImpl::GetInstance() {
   return Singleton<PluginServiceImpl>::get();
 }
 
 PluginServiceImpl::PluginServiceImpl()
     : plugin_list_(NULL), filter_(NULL) {
 }
 
 PluginServiceImpl::~PluginServiceImpl() {
@@ skipping 18 matching lines @@
   plugin_list_token_ = BrowserThread::GetBlockingPool()->GetSequenceToken();
   plugin_list_->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallbackWin, plugin_list_token_));
 #else
   plugin_list_->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallbackPosix));
 #endif
 
   RegisterPepperPlugins();
 
-  content::GetContentClient()->AddNPAPIPlugins(plugin_list_);
+  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);
 }
@@ skipping 107 matching lines @@
     const FilePath& profile_data_directory,
     PpapiPluginProcessHost::PluginClient* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PpapiPluginProcessHost* plugin_host =
       FindPpapiPluginProcess(plugin_path, profile_data_directory);
   if (plugin_host)
     return plugin_host;
 
   // Validate that the plugin is actually registered.
-  content::PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
+  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, profile_data_directory,
       client->GetResourceContext()->GetHostResolver());
 }
 
 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);
+  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);
 }
 
@@ skipping 64 matching lines @@
       params.resource_context);
 }
 
 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,
-    content::ResourceContext* resource_context) {
+    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;
 
@@ skipping 30 matching lines @@
     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 PluginServiceImpl::GetPluginInfo(int render_process_id,
                                       int render_view_id,
-                                      content::ResourceContext* context,
+                                      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(
@@ skipping 116 matching lines @@
 
 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(), true);
   }
 }
 
 // There should generally be very few plugins so a brute-force search is fine.
-content::PepperPluginInfo* PluginServiceImpl::GetRegisteredPpapiPluginInfo(
+PepperPluginInfo* PluginServiceImpl::GetRegisteredPpapiPluginInfo(
     const FilePath& plugin_path) {
-  content::PepperPluginInfo* info = NULL;
+  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;
+  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_OPENBSD)
 // static
 void PluginServiceImpl::RegisterFilePathWatcher(
     FilePathWatcher* watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif
 
-void PluginServiceImpl::SetFilter(content::PluginServiceFilter* filter) {
+void PluginServiceImpl::SetFilter(PluginServiceFilter* filter) {
   filter_ = filter;
 }
 
-content::PluginServiceFilter* PluginServiceImpl::GetFilter() {
+PluginServiceFilter* PluginServiceImpl::GetFilter() {
   return filter_;
 }
 
 void PluginServiceImpl::ForcePluginShutdown(const FilePath& plugin_path) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PluginServiceImpl::ForcePluginShutdown,
                    base::Unretained(this), plugin_path));
     return;
@@ skipping 78 matching lines @@
 }
 
 void PluginServiceImpl::GetInternalPlugins(
     std::vector<webkit::WebPluginInfo>* plugins) {
   plugin_list_->GetInternalPlugins(plugins);
 }
 
 webkit::npapi::PluginList* PluginServiceImpl::GetPluginList() {
   return plugin_list_;
 }
+
+}  // namespace content