Follow-up fixes to changing namespace gfx to gl.

ui/gl/gl_surface_egl.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 "ui/gl/gl_surface_egl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 108 matching lines @@
 EGLNativeDisplayType g_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_sync_control_supported = false;
 bool g_egl_window_fixed_size_supported = false;
 bool g_egl_surfaceless_context_supported = false;
 bool g_egl_surface_orientation_supported = false;
 bool g_use_direct_composition = false;
 
-class EGLSyncControlVSyncProvider : public gl::SyncControlVSyncProvider {
+class EGLSyncControlVSyncProvider : public SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
       : SyncControlVSyncProvider(),
         surface_(surface) {
   }
 
   ~EGLSyncControlVSyncProvider() override {}
 
  protected:
   bool GetSyncValues(int64_t* system_time,
@@ skipping 515 matching lines @@
 
   if (g_egl_window_fixed_size_supported && enable_fixed_size_angle_) {
     egl_window_attributes.push_back(EGL_FIXED_SIZE_ANGLE);
     egl_window_attributes.push_back(EGL_TRUE);
     egl_window_attributes.push_back(EGL_WIDTH);
     egl_window_attributes.push_back(size_.width());
     egl_window_attributes.push_back(EGL_HEIGHT);
     egl_window_attributes.push_back(size_.height());
   }
 
-  if (gl::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
+  if (g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     egl_window_attributes.push_back(EGL_POST_SUB_BUFFER_SUPPORTED_NV);
     egl_window_attributes.push_back(EGL_TRUE);
   }
 
   if (g_egl_surface_orientation_supported) {
     EGLint attrib;
     eglGetConfigAttrib(GetDisplay(), GetConfig(),
                        EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE, &attrib);
     flips_vertically_ = (attrib == EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE);
   }
@@ skipping 16 matching lines @@
   surface_ = eglCreateWindowSurface(
       GetDisplay(), GetConfig(), window_, &egl_window_attributes[0]);
 
   if (!surface_) {
     LOG(ERROR) << "eglCreateWindowSurface failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
-  if (gl::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
+  if (g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     EGLint surfaceVal;
     EGLBoolean retVal = eglQuerySurface(
         GetDisplay(), surface_, EGL_POST_SUB_BUFFER_SUPPORTED_NV, &surfaceVal);
     supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
   }
 
   if (sync_provider)
     vsync_provider_.reset(sync_provider.release());
   else if (g_egl_sync_control_supported)
     vsync_provider_.reset(new EGLSyncControlVSyncProvider(surface_));
@@ skipping 178 matching lines @@
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
 gfx::VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 bool NativeViewGLSurfaceEGL::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
-    gl::GLImage* image,
+    GLImage* image,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
 #if !defined(OS_ANDROID)
   NOTIMPLEMENTED();
   return false;
 #else
   pending_overlays_.push_back(
       GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 #endif
@@ skipping 137 matching lines @@
 
 EGLSurface PbufferGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
 void* PbufferGLSurfaceEGL::GetShareHandle() {
 #if defined(OS_ANDROID)
   NOTREACHED();
   return NULL;
 #else
-  if (!gl::g_driver_egl.ext.b_EGL_ANGLE_query_surface_pointer)
+  if (!g_driver_egl.ext.b_EGL_ANGLE_query_surface_pointer)
     return NULL;
 
-  if (!gl::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle)
+  if (!g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle)
     return NULL;
 
   void* handle;
   if (!eglQuerySurfacePointerANGLE(g_display,
                                    GetHandle(),
                                    EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE,
                                    &handle)) {
     return NULL;
   }
 
@@ skipping 51 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl