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

media/gpu/dxva_video_decode_accelerator_win.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 "media/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 367 matching lines @@
 template <class T>
 base::win::ScopedComPtr<T> QueryDeviceObjectFromANGLE(int object_type) {
   base::win::ScopedComPtr<T> device_object;
 
   EGLDisplay egl_display = nullptr;
   intptr_t egl_device = 0;
   intptr_t device = 0;
 
   {
     TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. GetHardwareDisplay");
-    egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+    egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   }
 
-  RETURN_ON_FAILURE(gfx::GLSurfaceEGL::HasEGLExtension("EGL_EXT_device_query"),
+  RETURN_ON_FAILURE(gl::GLSurfaceEGL::HasEGLExtension("EGL_EXT_device_query"),
                     "EGL_EXT_device_query missing", device_object);
 
   PFNEGLQUERYDISPLAYATTRIBEXTPROC QueryDisplayAttribEXT = nullptr;
 
   {
     TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. eglGetProcAddress");
 
     QueryDisplayAttribEXT = reinterpret_cast<PFNEGLQUERYDISPLAYATTRIBEXTPROC>(
         eglGetProcAddress("eglQueryDisplayAttribEXT"));
 
@@ skipping 256 matching lines @@
   }
 #endif
   // If we don't find the MFCreateDXGIDeviceManager API we fallback to D3D9
   // decoding.
   if (dxgi_manager_dll && !create_dxgi_device_manager_) {
     create_dxgi_device_manager_ = reinterpret_cast<CreateDXGIDeviceManager>(
         ::GetProcAddress(dxgi_manager_dll, "MFCreateDXGIDeviceManager"));
   }
 
   RETURN_AND_NOTIFY_ON_FAILURE(
-      gfx::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
+      gl::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
       "EGL_ANGLE_surface_d3d_texture_2d_share_handle unavailable",
       PLATFORM_FAILURE, false);
 
-  RETURN_AND_NOTIFY_ON_FAILURE(gfx::GLFence::IsSupported(),
+  RETURN_AND_NOTIFY_ON_FAILURE(gl::GLFence::IsSupported(),
                                "GL fences are unsupported", PLATFORM_FAILURE,
                                false);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kUninitialized),
                                "Initialize: invalid state: " << state,
                                ILLEGAL_STATE, false);
 
   media::InitializeMediaFoundation();
 
@@ skipping 305 matching lines @@
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
   if (it == output_picture_buffers_.end())
     return;
 
   DXVAPictureBuffer* picture_buffer = it->second.get();
 
   DCHECK(!picture_buffer->available());
   DCHECK(picture_buffer->waiting_to_reuse());
 
-  gfx::GLFence* fence = picture_buffer->reuse_fence();
+  gl::GLFence* fence = picture_buffer->reuse_fence();
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
   if (count <= kMaxIterationsForANGLEReuseFlush && !fence->HasCompleted()) {
     main_thread_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::WaitForOutputBuffer,
                               weak_this_factory_.GetWeakPtr(),
                               picture_buffer_id, count + 1),
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
     return;
@@ skipping 411 matching lines @@
   }
 
   hr = decoder_->ProcessMessage(MFT_MESSAGE_SET_D3D_MANAGER,
                                 device_manager_to_use);
   if (use_dx11_) {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass DX11 manager to decoder", false);
   } else {
     RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false);
   }
 
-  EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   EGLint config_attribs[] = {EGL_BUFFER_SIZE,  32,
                              EGL_RED_SIZE,     8,
                              EGL_GREEN_SIZE,   8,
                              EGL_BLUE_SIZE,    8,
                              EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
                              EGL_ALPHA_SIZE,   0,
                              EGL_NONE};
 
   EGLint num_configs;
@@ skipping 35 matching lines @@
   //    this. This should always be true for Windows 8+.
   // 3. ANGLE is using DX11.
   if (create_dxgi_device_manager_ &&
       (gl_context->GetGLRenderer().find("Direct3D11") != std::string::npos)) {
     UINT32 dx11_aware = 0;
     attributes->GetUINT32(MF_SA_D3D11_AWARE, &dx11_aware);
     use_dx11_ = !!dx11_aware;
   }
 
   use_keyed_mutex_ =
-      use_dx11_ && gfx::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
+      use_dx11_ && gl::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
 
   if (!use_dx11_ ||
-      !gfx::g_driver_egl.ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12 ||
-      !gfx::g_driver_egl.ext.b_EGL_KHR_stream ||
-      !gfx::g_driver_egl.ext.b_EGL_KHR_stream_consumer_gltexture ||
-      !gfx::g_driver_egl.ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
+      !gl::g_driver_egl.ext.b_EGL_ANGLE_stream_producer_d3d_texture_nv12 ||
+      !gl::g_driver_egl.ext.b_EGL_KHR_stream ||
+      !gl::g_driver_egl.ext.b_EGL_KHR_stream_consumer_gltexture ||
+      !gl::g_driver_egl.ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
     share_nv12_textures_ = false;
   }
 
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() {
   RETURN_ON_FAILURE(SetDecoderInputMediaType(),
                     "Failed to set decoder input media type", false);
   return SetDecoderOutputMediaType(MFVideoFormat_NV12);
@@ skipping 1142 matching lines @@
   DismissStaleBuffers(true);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media