ui/gl: Move GLImage into gl namespace.

gpu/command_buffer/service/texture_definition.cc

 // Copyright 2014 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 "gpu/command_buffer/service/texture_definition.h"
 
 #include <list>
 
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/scoped_binders.h"
 
 #if !defined(OS_MACOSX)
 #include "ui/gl/gl_surface_egl.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
-class GLImageSync : public gfx::GLImage {
+class GLImageSync : public gl::GLImage {
  public:
   explicit GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer,
                        const gfx::Size& size);
 
   // Implement GLImage.
   void Destroy(bool have_context) override;
   gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override;
@@ skipping 78 matching lines @@
 }
 
 #if !defined(OS_MACOSX)
 class NativeImageBufferEGL : public NativeImageBuffer {
  public:
   static scoped_refptr<NativeImageBufferEGL> Create(GLuint texture_id);
 
  private:
   NativeImageBufferEGL(EGLDisplay display, EGLImageKHR image);
   ~NativeImageBufferEGL() override;
-  void AddClient(gfx::GLImage* client) override;
-  void RemoveClient(gfx::GLImage* client) override;
-  bool IsClient(gfx::GLImage* client) override;
+  void AddClient(gl::GLImage* client) override;
+  void RemoveClient(gl::GLImage* client) override;
+  bool IsClient(gl::GLImage* client) override;
   void BindToTexture(GLenum target) const override;
 
   const EGLDisplay egl_display_;
   const EGLImageKHR egl_image_;
 
   base::Lock lock_;
 
   struct ClientInfo {
-    explicit ClientInfo(gfx::GLImage* client);
+    explicit ClientInfo(gl::GLImage* client);
     ~ClientInfo();
 
-    gfx::GLImage* client;
+    gl::GLImage* client;
     bool needs_wait_before_read;
   };
   std::list<ClientInfo> client_infos_;
-  gfx::GLImage* write_client_;
+  gl::GLImage* write_client_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferEGL);
 };
 
 scoped_refptr<NativeImageBufferEGL> NativeImageBufferEGL::Create(
     GLuint texture_id) {
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   EGLContext egl_context = eglGetCurrentContext();
 
   DCHECK_NE(EGL_NO_CONTEXT, egl_context);
@@ skipping 14 matching lines @@
 
   if (egl_image == EGL_NO_IMAGE_KHR) {
     LOG(ERROR) << "eglCreateImageKHR for cross-thread sharing failed: 0x"
                << std::hex << eglGetError();
     return NULL;
   }
 
   return new NativeImageBufferEGL(egl_display, egl_image);
 }
 
-NativeImageBufferEGL::ClientInfo::ClientInfo(gfx::GLImage* client)
+NativeImageBufferEGL::ClientInfo::ClientInfo(gl::GLImage* client)
     : client(client), needs_wait_before_read(true) {}
 
 NativeImageBufferEGL::ClientInfo::~ClientInfo() {}
 
 NativeImageBufferEGL::NativeImageBufferEGL(EGLDisplay display,
                                            EGLImageKHR image)
     : NativeImageBuffer(),
       egl_display_(display),
       egl_image_(image),
       write_client_(NULL) {
   DCHECK(egl_display_ != EGL_NO_DISPLAY);
   DCHECK(egl_image_ != EGL_NO_IMAGE_KHR);
 }
 
 NativeImageBufferEGL::~NativeImageBufferEGL() {
   DCHECK(client_infos_.empty());
   if (egl_image_ != EGL_NO_IMAGE_KHR)
     eglDestroyImageKHR(egl_display_, egl_image_);
 }
 
-void NativeImageBufferEGL::AddClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::AddClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   client_infos_.push_back(ClientInfo(client));
 }
 
-void NativeImageBufferEGL::RemoveClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::RemoveClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   if (write_client_ == client)
     write_client_ = NULL;
   for (std::list<ClientInfo>::iterator it = client_infos_.begin();
        it != client_infos_.end();
        it++) {
     if (it->client == client) {
       client_infos_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
-bool NativeImageBufferEGL::IsClient(gfx::GLImage* client) {
+bool NativeImageBufferEGL::IsClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   for (std::list<ClientInfo>::iterator it = client_infos_.begin();
        it != client_infos_.end();
        it++) {
     if (it->client == client)
       return true;
   }
   return false;
 }
 
 void NativeImageBufferEGL::BindToTexture(GLenum target) const {
   DCHECK(egl_image_ != EGL_NO_IMAGE_KHR);
   glEGLImageTargetTexture2DOES(target, egl_image_);
   DCHECK_EQ(static_cast<EGLint>(EGL_SUCCESS), eglGetError());
   DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 }
 
 #endif
 
 class NativeImageBufferStub : public NativeImageBuffer {
  public:
   NativeImageBufferStub() : NativeImageBuffer() {}
 
  private:
   ~NativeImageBufferStub() override {}
-  void AddClient(gfx::GLImage* client) override {}
-  void RemoveClient(gfx::GLImage* client) override {}
-  bool IsClient(gfx::GLImage* client) override { return true; }
+  void AddClient(gl::GLImage* client) override {}
+  void RemoveClient(gl::GLImage* client) override {}
+  bool IsClient(gl::GLImage* client) override { return true; }
   void BindToTexture(GLenum target) const override {}
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
 };
 
 bool g_avoid_egl_target_texture_reuse = false;
 
 }  // anonymous namespace
 
 // static
@@ skipping 75 matching lines @@
       immutable_(texture->IsImmutable()),
       defined_(texture->IsDefined()) {
   DCHECK_IMPLIES(image_buffer_.get(), defined_);
   if (!image_buffer_.get() && defined_) {
     image_buffer_ = NativeImageBuffer::Create(texture->service_id());
     DCHECK(image_buffer_.get());
   }
 
   const Texture::FaceInfo& first_face = texture->face_infos_[0];
   if (image_buffer_.get()) {
-    scoped_refptr<gfx::GLImage> gl_image(
+    scoped_refptr<gl::GLImage> gl_image(
         new GLImageSync(image_buffer_,
                         gfx::Size(first_face.level_infos[0].width,
                                   first_face.level_infos[0].height)));
     texture->SetLevelImage(target_, 0, gl_image.get(), Texture::BOUND);
   }
 
   const Texture::LevelInfo& level = first_face.level_infos[0];
   level_info_ = LevelInfo(level.target, level.internal_format, level.width,
                           level.height, level.depth, level.border, level.format,
                           level.type, level.cleared_rect);
@@ skipping 13 matching lines @@
 }
 
 void TextureDefinition::UpdateTextureInternal(Texture* texture) const {
   gfx::ScopedTextureBinder texture_binder(target_, texture->service_id());
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t_);
 
   if (image_buffer_.get()) {
-    gfx::GLImage* existing_image = texture->GetLevelImage(target_, 0);
+    gl::GLImage* existing_image = texture->GetLevelImage(target_, 0);
     // Don't need to re-bind if already bound before.
     if (!existing_image || !image_buffer_->IsClient(existing_image)) {
       image_buffer_->BindToTexture(target_);
     }
   }
 
   if (defined_) {
     texture->face_infos_.resize(1);
     texture->face_infos_[0].level_infos.resize(1);
     texture->SetLevelInfo(NULL, level_info_.target, 0,
@@ skipping 65 matching lines @@
   return true;
 }
 
 bool TextureDefinition::SafeToRenderFrom() const {
   return level_info_.cleared_rect.Contains(
       gfx::Rect(level_info_.width, level_info_.height));
 }
 
 }  // namespace gles2
 }  // namespace gpu