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

gpu/gles2_conform_support/egl/context.cc

 // Copyright (c) 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 "gpu/gles2_conform_support/egl/context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
@@ skipping 212 matching lines @@
 
 void Context::SignalSyncToken(const gpu::SyncToken& sync_token,
                               const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 bool Context::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
-void Context::ApplyCurrentContext(gfx::GLSurface* current_surface) {
+void Context::ApplyCurrentContext(gl::GLSurface* current_surface) {
   DCHECK(HasService());
   // The current_surface will be the same as
   // the surface of the decoder. We can not DCHECK as there is
   // no accessor.
   if (!WasServiceContextLost()) {
     if (!gl_context_->MakeCurrent(current_surface))
       MarkServiceContextLost();
   }
   gles2::SetGLContext(client_gl_context_.get());
 }
 
 void Context::ApplyContextReleased() {
   gles2::SetGLContext(nullptr);
 }
 
-bool Context::CreateService(gfx::GLSurface* gl_surface) {
+bool Context::CreateService(gl::GLSurface* gl_surface) {
   scoped_refptr<gpu::TransferBufferManager> transfer_buffer_manager(
       new gpu::TransferBufferManager(nullptr));
   transfer_buffer_manager->Initialize();
 
   std::unique_ptr<gpu::CommandBufferService> command_buffer(
       new gpu::CommandBufferService(transfer_buffer_manager.get()));
 
   scoped_refptr<gpu::gles2::FeatureInfo> feature_info(
       new gpu::gles2::FeatureInfo(gpu_driver_bug_workarounds_));
   scoped_refptr<gpu::gles2::ContextGroup> group(new gpu::gles2::ContextGroup(
       gpu_preferences_, nullptr, nullptr,
       new gpu::gles2::ShaderTranslatorCache(gpu_preferences_),
       new gpu::gles2::FramebufferCompletenessCache, feature_info, true));
 
   std::unique_ptr<gpu::gles2::GLES2Decoder> decoder(
       gpu::gles2::GLES2Decoder::Create(group.get()));
   if (!decoder.get())
     return false;
 
   std::unique_ptr<gpu::CommandExecutor> command_executor(
       new gpu::CommandExecutor(command_buffer.get(), decoder.get(),
                                decoder.get()));
 
   decoder->set_engine(command_executor.get());
 
-  scoped_refptr<gfx::GLContext> gl_context(
-      gl::init::CreateGLContext(nullptr, gl_surface, gfx::PreferDiscreteGpu));
+  scoped_refptr<gl::GLContext> gl_context(
+      gl::init::CreateGLContext(nullptr, gl_surface, gl::PreferDiscreteGpu));
   if (!gl_context)
     return false;
 
   gl_context->MakeCurrent(gl_surface);
 
   gpu::gles2::ContextCreationAttribHelper helper;
   config_->GetAttrib(EGL_ALPHA_SIZE, &helper.alpha_size);
   config_->GetAttrib(EGL_DEPTH_SIZE, &helper.depth_size);
   config_->GetAttrib(EGL_STENCIL_SIZE, &helper.stencil_size);
 
@@ skipping 87 matching lines @@
   // because GTF windowless window surfaces might be emulated with offscreen
   // surfaces.
   EGLint value = EGL_NONE;
   config_->GetAttrib(EGL_SURFACE_TYPE, &value);
   bool context_config_is_offscreen = (value & EGL_PBUFFER_BIT) != 0;
   surface->config()->GetAttrib(EGL_SURFACE_TYPE, &value);
   bool surface_config_is_offscreen = (value & EGL_PBUFFER_BIT) != 0;
   return surface_config_is_offscreen == context_config_is_offscreen;
 }
 
-bool Context::Flush(gfx::GLSurface* gl_surface) {
+bool Context::Flush(gl::GLSurface* gl_surface) {
   if (WasServiceContextLost())
     return false;
   if (!gl_context_->MakeCurrent(gl_surface)) {
     MarkServiceContextLost();
     return false;
   }
   client_gl_context_->Flush();
   return true;
 }
 
 }  // namespace egl