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

gpu/gles2_conform_support/egl/display.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 "gpu/gles2_conform_support/egl/display.h"
 
 #include "gpu/gles2_conform_support/egl/config.h"
 #include "gpu/gles2_conform_support/egl/context.h"
 #include "gpu/gles2_conform_support/egl/surface.h"
 #include "gpu/gles2_conform_support/egl/thread_state.h"
@@ skipping 160 matching lines @@
     }
   }
   return DoCreatePbufferSurface(ts, config, width, height);
 }
 
 EGLSurface Display::DoCreatePbufferSurface(ThreadState* ts,
                                            const Config* config,
                                            EGLint width,
                                            EGLint height) {
   lock_.AssertAcquired();
-  scoped_refptr<gfx::GLSurface> gl_surface;
+  scoped_refptr<gl::GLSurface> gl_surface;
   gl_surface = gl::init::CreateOffscreenGLSurface(gfx::Size(width, height));
   if (!gl_surface)
     return ts->ReturnError(EGL_BAD_ALLOC, nullptr);
   surfaces_.emplace_back(new Surface(gl_surface.get(), config));
   return ts->ReturnSuccess<EGLSurface>(surfaces_.back().get());
 }
 
 EGLSurface Display::CreateWindowSurface(ThreadState* ts,
                                         EGLConfig cfg,
                                         EGLNativeWindowType win,
@@ skipping 14 matching lines @@
     return ts->ReturnError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
   if (next_create_window_surface_creates_pbuffer_) {
     EGLSurface result = DoCreatePbufferSurface(ts, config,
                                                window_surface_pbuffer_width_,
                                                window_surface_pbuffer_height_);
     next_create_window_surface_creates_pbuffer_ = false;
     window_surface_pbuffer_width_ = 0;
     window_surface_pbuffer_height_ = 0;
     return result;
   }
-  scoped_refptr<gfx::GLSurface> gl_surface;
+  scoped_refptr<gl::GLSurface> gl_surface;
   gl_surface = gl::init::CreateViewGLSurface(win);
   if (!gl_surface)
     return ts->ReturnError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
   surfaces_.emplace_back(new Surface(gl_surface.get(), config));
   return ts->ReturnSuccess(surfaces_.back().get());
 }
 
 EGLBoolean Display::DestroySurface(ThreadState* ts, EGLSurface sfe) {
   base::AutoLock auto_lock(lock_);
   if (!is_initialized_)
@@ skipping 133 matching lines @@
 
 bool Display::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncRelease(release);
 }
 
 void Display::InitializeConfigsIfNeeded() {
   lock_.AssertAcquired();
   if (!configs_[0]) {
     // The interface offers separate configs for window and pbuffer.
     // This way we can record the client intention at context creation time.
-    // The GL implementation (gfx::GLContext and gfx::GLSurface) needs this
+    // The GL implementation (gl::GLContext and gl::GLSurface) needs this
     // distinction when creating a context.
     configs_[0].reset(new Config(EGL_WINDOW_BIT));
     configs_[1].reset(new Config(EGL_PBUFFER_BIT));
   }
 }
 
 const Config* Display::GetConfig(EGLConfig cfg) {
   lock_.AssertAcquired();
   for (const auto& config : configs_) {
     if (config.get() == cfg)
@@ skipping 12 matching lines @@
 
 Context* Display::GetContext(EGLContext context) {
   lock_.AssertAcquired();
   auto it = std::find(contexts_.begin(), contexts_.end(), context);
   if (it == contexts_.end())
     return nullptr;
   return it->get();
 }
 
 }  // namespace egl