Move a bunch of code in content\common (as well as a few left in renderer) to the content namespace.

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 18 matching lines @@
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/common/gpu/stream_texture_manager_android.h"
 #endif
 
+namespace content {
 namespace {
 // This filter does two things:
 // - it counts the number of messages coming in on the channel
 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
 //   thread, generating the sync point ID and responding immediately, and then
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 class SyncPointMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   // Takes ownership of gpu_channel (see below).
@@ skipping 114 matching lines @@
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
 #if defined(OS_ANDROID)
-  stream_texture_manager_.reset(new content::StreamTextureManagerAndroid(this));
+  stream_texture_manager_.reset(new StreamTextureManagerAndroid(this));
 #endif
 }
 
 
 bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
                       base::WaitableEvent* shutdown_event) {
   DCHECK(!channel_.get());
 
   // Map renderer ID to a (single) channel to that process.
   channel_.reset(new IPC::SyncChannel(
@@ skipping 380 matching lines @@
     int32 stream_id,  const gfx::Size& initial_size, int32* route_id) {
   // Note that route_id is only used for notifications sent out from here.
   // StreamTextureManager owns all texture objects and for incoming messages
   // it finds the correct object based on stream_id.
   *route_id = GenerateRouteID();
   stream_texture_manager_->RegisterStreamTextureProxy(
       stream_id, initial_size, *route_id);
 }
 
 void GpuChannel::OnEstablishStreamTexture(
-    int32 stream_id, content::SurfaceTexturePeer::SurfaceTextureTarget type,
+    int32 stream_id, SurfaceTexturePeer::SurfaceTextureTarget type,
     int32 primary_id, int32 secondary_id) {
   stream_texture_manager_->EstablishStreamTexture(
       stream_id, type, primary_id, secondary_id);
 }
 #endif
 
 void GpuChannel::OnCollectRenderingStatsForSurface(
     int32 surface_id, IPC::Message* reply_message) {
-  content::GpuRenderingStats stats;
+  GpuRenderingStats stats;
 
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     int texture_upload_count =
         it.GetCurrentValue()->decoder()->GetTextureUploadCount();
     base::TimeDelta total_texture_upload_time =
         it.GetCurrentValue()->decoder()->GetTotalTextureUploadTime();
     base::TimeDelta total_processing_commands_time =
         it.GetCurrentValue()->decoder()->GetTotalProcessingCommandsTime();
 
     stats.global_texture_upload_count += texture_upload_count;
     stats.global_total_texture_upload_time += total_texture_upload_time;
     stats.global_total_processing_commands_time +=
         total_processing_commands_time;
     if (it.GetCurrentValue()->surface_id() == surface_id) {
       stats.texture_upload_count += texture_upload_count;
       stats.total_texture_upload_time += total_texture_upload_time;
       stats.total_processing_commands_time += total_processing_commands_time;
     }
   }
 
   GpuChannelMsg_CollectRenderingStatsForSurface::WriteReplyParams(
       reply_message,
       stats);
   Send(reply_message);
 }
+
+}  // namespace content