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

content/common/gpu/texture_image_transport_surface.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/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "content/common/gpu/gl_scoped_binders.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 
 using gpu::gles2::ContextGroup;
 using gpu::gles2::TextureManager;
 typedef TextureManager::TextureInfo TextureInfo;
 
+namespace content {
+
 TextureImageTransportSurface::Texture::Texture()
     : client_id(0),
       sent_to_client(false) {
 }
 
 TextureImageTransportSurface::Texture::~Texture() {
 }
 
 TextureImageTransportSurface::TextureImageTransportSurface(
     GpuChannelManager* manager,
@@ skipping 263 matching lines @@
   int back_texture_service_id = textures_[back()].info->service_id();
   int front_texture_service_id = textures_[front()].info->service_id();
 
   gfx::Size expected_size = textures_[back()].size;
   bool surfaces_same_size = textures_[front()].size == expected_size;
 
   if (surfaces_same_size) {
     std::vector<gfx::Rect> regions_to_copy;
     GetRegionsToCopy(previous_damage_rect_, new_damage_rect, &regions_to_copy);
 
-    content::ScopedFrameBufferBinder fbo_binder(fbo_id_);
+    ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
         GL_COLOR_ATTACHMENT0,
         GL_TEXTURE_2D,
         front_texture_service_id,
         0);
-    content::ScopedTextureBinder texture_binder(back_texture_service_id);
+    ScopedTextureBinder texture_binder(back_texture_service_id);
 
     for (size_t i = 0; i < regions_to_copy.size(); ++i) {
       const gfx::Rect& region_to_copy = regions_to_copy[i];
       if (!region_to_copy.IsEmpty()) {
         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, region_to_copy.x(),
             region_to_copy.y(), region_to_copy.x(), region_to_copy.y(),
             region_to_copy.width(), region_to_copy.height());
       }
     }
   } else {
@@ skipping 113 matching lines @@
   Texture& texture = textures_[id];
   TextureInfo* info = texture.info;
   DCHECK(info);
 
   GLuint service_id = info->service_id();
   if (!service_id)
     return;
   info->SetServiceId(0);
 
   {
-    content::ScopedFrameBufferBinder fbo_binder(fbo_id_);
+    ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glDeleteTextures(1, &service_id);
   }
   glFlush();
   CHECK_GL_ERROR();
 }
 
 void TextureImageTransportSurface::CreateBackTexture(const gfx::Size& size) {
   if (!parent_stub_)
     return;
   Texture& texture = textures_[back()];
@@ skipping 22 matching lines @@
         size.width(),
         size.height(),
         1,
         0,
         GL_RGBA,
         GL_UNSIGNED_BYTE,
         true);
   }
 
   {
-    content::ScopedTextureBinder texture_binder(service_id);
+    ScopedTextureBinder texture_binder(service_id);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
         size.width(), size.height(), 0,
         GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     CHECK_GL_ERROR();
   }
 
   AttachBackTextureToFBO();
 
   GpuHostMsg_AcceleratedSurfaceNew_Params params;
   params.width = size.width();
   params.height = size.height();
   params.surface_handle = texture.client_id;
   helper_->SendAcceleratedSurfaceNew(params);
   texture.sent_to_client = true;
 }
 
 void TextureImageTransportSurface::AttachBackTextureToFBO() {
   if (!parent_stub_)
     return;
   TextureInfo* info = textures_[back()].info;
   DCHECK(info);
 
-  content::ScopedFrameBufferBinder fbo_binder(fbo_id_);
+  ScopedFrameBufferBinder fbo_binder(fbo_id_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
       GL_COLOR_ATTACHMENT0,
       GL_TEXTURE_2D,
       info->service_id(),
       0);
   glFlush();
   CHECK_GL_ERROR();
 
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
@@ skipping 10 matching lines @@
     Texture& texture = textures_[i];
     texture.info = NULL;
     if (!texture.sent_to_client)
       continue;
     GpuHostMsg_AcceleratedSurfaceRelease_Params params;
     params.identifier = texture.client_id;
     helper_->SendAcceleratedSurfaceRelease(params);
   }
   parent_stub_ = NULL;
 }
+
+}  // namespace content