Refactor content/common/gpu into gpu/ipc/service

gpu/ipc/service/stream_texture_android.cc

 // Copyright (c) 2013 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/stream_texture_android.h"
+#include "gpu/ipc/service/stream_texture_android.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/strings/stringize_macros.h"
-#include "content/common/gpu/gpu_channel.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/ipc/common/android/surface_texture_peer.h"
 #include "gpu/ipc/common/gpu_messages.h"
+#include "gpu/ipc/service/gpu_channel.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_helper.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 
-namespace content {
+namespace gpu {
 
-using gpu::gles2::ContextGroup;
-using gpu::gles2::GLES2Decoder;
-using gpu::gles2::TextureManager;
-using gpu::gles2::TextureRef;
+using gles2::ContextGroup;
+using gles2::GLES2Decoder;
+using gles2::TextureManager;
+using gles2::TextureRef;
 
 // static
 bool StreamTexture::Create(GpuCommandBufferStub* owner_stub,
                            uint32_t client_texture_id,
                            int stream_id) {
   GLES2Decoder* decoder = owner_stub->decoder();
   TextureManager* texture_manager =
       decoder->GetContextGroup()->texture_manager();
   TextureRef* texture = texture_manager->GetTexture(client_texture_id);
 
   if (texture && (!texture->texture()->target() ||
                   texture->texture()->target() == GL_TEXTURE_EXTERNAL_OES)) {
 
     // TODO: Ideally a valid image id was returned to the client so that
     // it could then call glBindTexImage2D() for doing the following.
-    scoped_refptr<gpu::gles2::GLStreamTextureImage> gl_image(
+    scoped_refptr<gles2::GLStreamTextureImage> gl_image(
         new StreamTexture(owner_stub, stream_id, texture->service_id()));
     gfx::Size size = gl_image->GetSize();
     texture_manager->SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
     texture_manager->SetLevelInfo(texture, GL_TEXTURE_EXTERNAL_OES, 0, GL_RGBA,
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect(size));
     texture_manager->SetLevelStreamTextureImage(
         texture, GL_TEXTURE_EXTERNAL_OES, 0, gl_image.get(),
-        gpu::gles2::Texture::UNBOUND);
+        gles2::Texture::UNBOUND);
     return true;
   }
 
   return false;
 }
 
 StreamTexture::StreamTexture(GpuCommandBufferStub* owner_stub,
                              int32_t route_id,
                              uint32_t texture_id)
     : surface_texture_(gfx::SurfaceTexture::Create(texture_id)),
@@ skipping 82 matching lines @@
 
   surface_texture_->UpdateTexImage();
 
   has_pending_frame_ = false;
 
   if (scoped_make_current.get()) {
     // UpdateTexImage() implies glBindTexture().
     // The cmd decoder takes care of restoring the binding for this GLImage as
     // far as the current context is concerned, but if we temporarily change
     // it, we have to keep the state intact in *that* context also.
-    const gpu::gles2::ContextState* state =
+    const gles2::ContextState* state =
         owner_stub_->decoder()->GetContextState();
-    const gpu::gles2::TextureUnit& active_unit =
+    const gles2::TextureUnit& active_unit =
         state->texture_units[state->active_texture_unit];
     glBindTexture(GL_TEXTURE_EXTERNAL_OES,
                   active_unit.bound_texture_external_oes.get()
                       ? active_unit.bound_texture_external_oes->service_id()
                       : 0);
   }
 }
 
 bool StreamTexture::CopyTexImage(unsigned target) {
   if (target != GL_TEXTURE_EXTERNAL_OES)
@@ skipping 10 matching lines @@
   // On some devices GL_TEXTURE_BINDING_EXTERNAL_OES is not supported as
   // glGetIntegerv() parameter. In this case the value of |texture_id| will be
   // zero and we assume that it is properly bound to |texture_id_|.
   if (texture_id > 0 && static_cast<unsigned>(texture_id) != texture_id_)
     return false;
 
   UpdateTexImage();
 
   TextureManager* texture_manager =
       owner_stub_->decoder()->GetContextGroup()->texture_manager();
-  gpu::gles2::Texture* texture =
+  gles2::Texture* texture =
       texture_manager->GetTextureForServiceId(texture_id_);
   if (texture) {
     // By setting image state to UNBOUND instead of COPIED we ensure that
     // CopyTexImage() is called each time the surface texture is used for
     // drawing.
     texture->SetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0, this,
-                                        gpu::gles2::Texture::UNBOUND);
+                                        gles2::Texture::UNBOUND);
   }
 
   return true;
 }
 
 void StreamTexture::OnFrameAvailable() {
   has_pending_frame_ = true;
   if (has_listener_ && owner_stub_) {
     owner_stub_->channel()->Send(
         new GpuStreamTextureMsg_FrameAvailable(route_id_));
@@ skipping 25 matching lines @@
   DCHECK(!has_listener_);
   has_listener_ = true;
 }
 
 void StreamTexture::OnEstablishPeer(int32_t primary_id, int32_t secondary_id) {
   if (!owner_stub_)
     return;
 
   base::ProcessHandle process = owner_stub_->channel()->GetClientPID();
 
-  gpu::SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
+  SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
       process, surface_texture_, primary_id, secondary_id);
 }
 
 bool StreamTexture::BindTexImage(unsigned target) {
   NOTREACHED();
   return false;
 }
 
 void StreamTexture::ReleaseTexImage(unsigned target) {
   NOTREACHED();
@@ skipping 13 matching lines @@
   NOTREACHED();
   return false;
 }
 
 void StreamTexture::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  uint64_t process_tracing_id,
                                  const std::string& dump_name) {
   // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
 }
 
-}  // namespace content
+}  // namespace gpu