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

content/browser/plugin_process_host.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_process_host.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <utility>  // for pair<>
@@ skipping 21 matching lines @@
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_switches.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_switches.h"
 
-using content::BrowserThread;
-using content::ChildProcessData;
-using content::ChildProcessHost;
-
 #if defined(USE_X11)
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "content/common/plugin_carbon_interpose_constants_mac.h"
 #include "ui/gfx/rect.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
+#endif
 
+namespace content {
+
+#if defined(OS_WIN)
 void PluginProcessHost::OnPluginWindowDestroyed(HWND window, HWND parent) {
   // The window is destroyed at this point, we just care about its parent, which
   // is the intermediate window we created.
   std::set<HWND>::iterator window_index =
       plugin_parent_windows_set_.find(parent);
   if (window_index == plugin_parent_windows_set_.end())
     return;
 
   plugin_parent_windows_set_.erase(window_index);
   PostMessage(parent, WM_CLOSE, 0, 0);
@@ skipping 13 matching lines @@
   GtkNativeViewManager::GetInstance()->GetXIDForId(output, id);
 #endif
 }
 #endif  // defined(TOOLKIT_GTK)
 
 PluginProcessHost::PluginProcessHost()
 #if defined(OS_MACOSX)
     : plugin_cursor_visible_(true)
 #endif
 {
-  process_.reset(
-      new BrowserChildProcessHostImpl(content::PROCESS_TYPE_PLUGIN, this));
+  process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_PLUGIN, this));
 }
 
 PluginProcessHost::~PluginProcessHost() {
 #if defined(OS_WIN)
   // We erase HWNDs from the plugin_parent_windows_set_ when we receive a
   // notification that the window is being destroyed. If we don't receive this
   // notification and the PluginProcessHost instance is being destroyed, it
   // means that the plugin process crashed. We paint a sad face in this case in
   // the renderer process. To ensure that the sad face shows up, and we don't
   // leak HWNDs, we should destroy existing plugin parent windows.
@@ skipping 95 matching lines @@
 
   cmd_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
                              arraysize(kSwitchNames));
 
   GpuDataManagerImpl::GetInstance()->AppendPluginCommandLine(cmd_line);
 
   // If specified, prepend a launcher program to the command line.
   if (!plugin_launcher.empty())
     cmd_line->PrependWrapper(plugin_launcher);
 
-  std::string locale =
-      content::GetContentClient()->browser()->GetApplicationLocale();
+  std::string locale = GetContentClient()->browser()->GetApplicationLocale();
   if (!locale.empty()) {
     // Pass on the locale so the null plugin will use the right language in the
     // prompt to install the desired plugin.
     cmd_line->AppendSwitchASCII(switches::kLang, locale);
   }
 
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
 
 #if defined(OS_POSIX)
   base::EnvironmentVector env;
 #if defined(OS_MACOSX) && !defined(__LP64__)
   if (!browser_command_line.HasSwitch(switches::kDisableCarbonInterposing)) {
-    std::string interpose_list =
-        content::GetContentClient()->GetCarbonInterposePath();
+    std::string interpose_list = GetContentClient()->GetCarbonInterposePath();
     if (!interpose_list.empty()) {
       // Add our interposing library for Carbon. This is stripped back out in
       // plugin_main.cc, so changes here should be reflected there.
-      const char* existing_list =
-          getenv(plugin_interpose_strings::kDYLDInsertLibrariesKey);
+      const char* existing_list = getenv(kDYLDInsertLibrariesKey);
       if (existing_list) {
         interpose_list.insert(0, ":");
         interpose_list.insert(0, existing_list);
       }
     }
     env.push_back(std::pair<std::string, std::string>(
-        plugin_interpose_strings::kDYLDInsertLibrariesKey,
-        interpose_list));
+        kDYLDInsertLibrariesKey, interpose_list));
   }
 #endif
 #endif
 
   process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       false,
       env,
@@ skipping 76 matching lines @@
   while (!sent_requests_.empty()) {
     Client* client = sent_requests_.front();
     if (client)
       client->OnError();
     sent_requests_.pop_front();
   }
 }
 
 // static
 void PluginProcessHost::CancelPendingRequestsForResourceContext(
-    content::ResourceContext* context) {
+    ResourceContext* context) {
   for (PluginProcessHostIterator host_it; !host_it.Done(); ++host_it) {
     PluginProcessHost* host = *host_it;
     for (size_t i = 0; i < host->pending_requests_.size(); ++i) {
       if (host->pending_requests_[i]->GetResourceContext() == context) {
         host->pending_requests_[i]->OnError();
         host->pending_requests_.erase(host->pending_requests_.begin() + i);
         --i;
       }
     }
   }
 }
 
 void PluginProcessHost::OpenChannelToPlugin(Client* client) {
-  process_->Notify(content::NOTIFICATION_CHILD_INSTANCE_CREATED);
+  process_->Notify(NOTIFICATION_CHILD_INSTANCE_CREATED);
   client->SetPluginInfo(info_);
   if (process_->GetHost()->IsChannelOpening()) {
     // The channel is already in the process of being opened.  Put
     // this "open channel" request into a queue of requests that will
     // be run once the channel is open.
     pending_requests_.push_back(client);
     return;
   }
 
   // We already have an open channel, send a request right away to plugin.
@@ skipping 44 matching lines @@
 }
 
 void PluginProcessHost::OnChannelCreated(
     const IPC::ChannelHandle& channel_handle) {
   Client* client = sent_requests_.front();
 
   if (client)
     client->OnChannelOpened(channel_handle);
   sent_requests_.pop_front();
 }
+
+}  // namespace content