Move code in ui/gl/* from gfx:: to gl::

media/gpu/dxva_picture_buffer_win.cc

 // Copyright 2016 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 "media/gpu/dxva_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 56 matching lines @@
     ID3D11Texture2D* dx11_texture,
     int input_buffer_id) {
   NOTREACHED();
   return false;
 }
 
 bool DXVAPictureBuffer::waiting_to_reuse() const {
   return false;
 }
 
-gfx::GLFence* DXVAPictureBuffer::reuse_fence() {
+gl::GLFence* DXVAPictureBuffer::reuse_fence() {
   return nullptr;
 }
 
 bool DXVAPictureBuffer::CopySurfaceComplete(IDirect3DSurface9* src_surface,
                                             IDirect3DSurface9* dest_surface) {
   NOTREACHED();
   return false;
 }
 
 DXVAPictureBuffer::DXVAPictureBuffer(const media::PictureBuffer& buffer)
     : available_(true), picture_buffer_(buffer) {}
 
 bool DXVAPictureBuffer::BindSampleToTexture(
     base::win::ScopedComPtr<IMFSample> sample) {
   NOTREACHED();
   return false;
 }
 
 bool PbufferPictureBuffer::Initialize(const DXVAVideoDecodeAccelerator& decoder,
                                       EGLConfig egl_config) {
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   EGLint use_rgb = 1;
   eglGetConfigAttrib(egl_display, egl_config, EGL_BIND_TO_TEXTURE_RGB,
                      &use_rgb);
 
   if (!InitializeTexture(decoder, !!use_rgb))
     return false;
 
   EGLint attrib_list[] = {EGL_WIDTH,
                           size().width(),
                           EGL_HEIGHT,
@@ skipping 65 matching lines @@
         D3DPOOL_DEFAULT, decoding_texture_.Receive(), &texture_share_handle_);
     RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
     RETURN_ON_FAILURE(texture_share_handle_, "Failed to query shared handle",
                       false);
   }
   return true;
 }
 
 void PbufferPictureBuffer::ResetReuseFence() {
   if (!reuse_fence_ || !reuse_fence_->ResetSupported())
-    reuse_fence_.reset(gfx::GLFence::Create());
+    reuse_fence_.reset(gl::GLFence::Create());
   else
     reuse_fence_->ResetState();
   waiting_to_reuse_ = true;
 }
 
 bool PbufferPictureBuffer::CopyOutputSampleDataToPictureBuffer(
     DXVAVideoDecodeAccelerator* decoder,
     IDirect3DSurface9* dest_surface,
     ID3D11Texture2D* dx11_texture,
     int input_buffer_id) {
@@ skipping 42 matching lines @@
 
   decoder->CopySurface(decoder_surface_.get(), target_surface_.get(), id(),
                        input_buffer_id);
   return true;
 }
 
 bool PbufferPictureBuffer::waiting_to_reuse() const {
   return waiting_to_reuse_;
 }
 
-gfx::GLFence* PbufferPictureBuffer::reuse_fence() {
+gl::GLFence* PbufferPictureBuffer::reuse_fence() {
   return reuse_fence_.get();
 }
 
 bool PbufferPictureBuffer::CopySurfaceComplete(
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface) {
   DCHECK(!available());
 
   GLint current_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
@@ skipping 11 matching lines @@
     DCHECK(decoder_dx11_texture_.get());
     decoder_dx11_texture_.Release();
   }
   if (egl_keyed_mutex_) {
     keyed_mutex_value_++;
     HRESULT result =
         egl_keyed_mutex_->AcquireSync(keyed_mutex_value_, kAcquireSyncWaitMs);
     RETURN_ON_FAILURE(result == S_OK, "Could not acquire sync mutex", false);
   }
 
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   eglBindTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glBindTexture(GL_TEXTURE_2D, current_texture);
   return true;
 }
 
 PbufferPictureBuffer::PbufferPictureBuffer(const media::PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer),
       waiting_to_reuse_(false),
       decoding_surface_(NULL),
       texture_share_handle_(nullptr),
       keyed_mutex_value_(0),
       use_rgb_(true) {}
 
 PbufferPictureBuffer::~PbufferPictureBuffer() {
   if (decoding_surface_) {
-    EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
     eglReleaseTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
 
     eglDestroySurface(egl_display, decoding_surface_);
     decoding_surface_ = NULL;
   }
 }
 
 bool PbufferPictureBuffer::ReusePictureBuffer() {
   DCHECK(decoding_surface_);
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
 
   decoder_surface_.Release();
   target_surface_.Release();
   decoder_dx11_texture_.Release();
   waiting_to_reuse_ = false;
   set_available(true);
   if (egl_keyed_mutex_) {
     HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
     RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
   }
   return true;
 }
 
 EGLStreamPictureBuffer::EGLStreamPictureBuffer(
     const media::PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer), stream_(nullptr) {}
 
 EGLStreamPictureBuffer::~EGLStreamPictureBuffer() {
   if (stream_) {
-    EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
     eglDestroyStreamKHR(egl_display, stream_);
     stream_ = nullptr;
   }
 }
 
 bool EGLStreamPictureBuffer::Initialize() {
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   const EGLint stream_attributes[] = {
       EGL_CONSUMER_LATENCY_USEC_KHR,
       0,
       EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR,
       0,
       EGL_NONE,
   };
   stream_ = eglCreateStreamKHR(egl_display, stream_attributes);
   RETURN_ON_FAILURE(!!stream_, "Could not create stream", false);
-  gfx::ScopedActiveTexture texture0(GL_TEXTURE0);
-  gfx::ScopedTextureBinder texture0_binder(GL_TEXTURE_EXTERNAL_OES,
-                                           picture_buffer_.texture_ids()[0]);
-  gfx::ScopedActiveTexture texture1(GL_TEXTURE1);
-  gfx::ScopedTextureBinder texture1_binder(GL_TEXTURE_EXTERNAL_OES,
-                                           picture_buffer_.texture_ids()[1]);
+  gl::ScopedActiveTexture texture0(GL_TEXTURE0);
+  gl::ScopedTextureBinder texture0_binder(GL_TEXTURE_EXTERNAL_OES,
+                                          picture_buffer_.texture_ids()[0]);
+  gl::ScopedActiveTexture texture1(GL_TEXTURE1);
+  gl::ScopedTextureBinder texture1_binder(GL_TEXTURE_EXTERNAL_OES,
+                                          picture_buffer_.texture_ids()[1]);
 
   EGLAttrib consumer_attributes[] = {
       EGL_COLOR_BUFFER_TYPE,
       EGL_YUV_BUFFER_EXT,
       EGL_YUV_NUMBER_OF_PLANES_EXT,
       2,
       EGL_YUV_PLANE0_TEXTURE_UNIT_NV,
       0,
       EGL_YUV_PLANE1_TEXTURE_UNIT_NV,
       1,
       EGL_NONE,
   };
   EGLBoolean result = eglStreamConsumerGLTextureExternalAttribsNV(
       egl_display, stream_, consumer_attributes);
   RETURN_ON_FAILURE(result, "Could not set stream consumer", false);
 
   EGLAttrib producer_attributes[] = {
       EGL_NONE,
   };
 
   result = eglCreateStreamProducerD3DTextureNV12ANGLE(egl_display, stream_,
                                                       producer_attributes);
   RETURN_ON_FAILURE(result, "Could not create stream producer", false);
   return true;
 }
 
 bool EGLStreamPictureBuffer::ReusePictureBuffer() {
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   if (stream_) {
     EGLBoolean result = eglStreamConsumerReleaseKHR(egl_display, stream_);
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   if (current_d3d_sample_) {
     dx11_decoding_texture_.Release();
     current_d3d_sample_.Release();
   }
   set_available(true);
   return true;
 }
 
 bool EGLStreamPictureBuffer::BindSampleToTexture(
     base::win::ScopedComPtr<IMFSample> sample) {
   DCHECK(!available());
 
   current_d3d_sample_ = sample;
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr =
       current_d3d_sample_->GetBufferByIndex(0, output_buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
   base::win::ScopedComPtr<IMFDXGIBuffer> dxgi_buffer;
   hr = dxgi_buffer.QueryFrom(output_buffer.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to get DXGIBuffer from output sample",
                        false);
   hr = dxgi_buffer->GetResource(IID_PPV_ARGS(dx11_decoding_texture_.Receive()));
   RETURN_ON_HR_FAILURE(hr, "Failed to get texture from output sample", false);
   UINT subresource;
   dxgi_buffer->GetSubresourceIndex(&subresource);
 
   EGLAttrib frame_attributes[] = {
       EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, subresource, EGL_NONE,
   };
 
   EGLBoolean result = eglStreamPostD3DTextureNV12ANGLE(
       egl_display, stream_, static_cast<void*>(dx11_decoding_texture_.get()),
       frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post texture", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   return true;
 }
 
 }  // namespace media