Follow-up fixes to changing namespace gfx to gl.

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 14 matching lines @@
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_overlay.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
-using gl::GLImage;
-
 namespace gl {
 
 namespace {
 
 // Helper function for base::Bind to create callback to eglChooseConfig.
 bool EglChooseConfig(EGLDisplay display,
                      const int32_t* attribs,
                      EGLConfig* configs,
                      int32_t config_size,
                      int32_t* num_configs) {
@@ skipping 22 matching lines @@
                        EGL_FOREVER_KHR);
 }
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow.
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     gfx::AcceleratedWidget widget);
 
   // GLSurface:
-  bool Initialize(gl::GLSurface::Format format) override;
+  bool Initialize(GLSurface::Format format) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             gfx::OverlayTransform transform,
                             GLImage* image,
                             const gfx::Rect& bounds_rect,
                             const gfx::RectF& crop_rect) override;
   EGLConfig GetConfig() override;
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL);
 };
 
 GLSurfaceOzoneEGL::GLSurfaceOzoneEGL(
     std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     gfx::AcceleratedWidget widget)
     : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget) {}
 
-bool GLSurfaceOzoneEGL::Initialize(gl::GLSurface::Format format) {
+bool GLSurfaceOzoneEGL::Initialize(GLSurface::Format format) {
   format_ = format;
   return Initialize(ozone_surface_->CreateVSyncProvider());
 }
 
 bool GLSurfaceOzoneEGL::Resize(const gfx::Size& size,
                                float scale_factor,
                                bool has_alpha) {
   if (!ozone_surface_->ResizeNativeWindow(size)) {
     if (!ReinitializeNativeSurface() ||
         !ozone_surface_->ResizeNativeWindow(size))
@@ skipping 60 matching lines @@
 
   return true;
 }
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             gfx::AcceleratedWidget widget);
 
   // GLSurface:
-  bool Initialize(gl::GLSurface::Format format) override;
+  bool Initialize(GLSurface::Format format) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             gfx::OverlayTransform transform,
                             GLImage* image,
                             const gfx::Rect& bounds_rect,
                             const gfx::RectF& crop_rect) override;
   bool IsOffscreen() override;
@@ skipping 62 matching lines @@
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
       last_swap_buffers_result_(true),
       swap_buffers_pending_(false),
       weak_factory_(this) {
   unsubmitted_frames_.push_back(new PendingFrame());
 }
 
-bool GLSurfaceOzoneSurfaceless::Initialize(gl::GLSurface::Format format) {
+bool GLSurfaceOzoneSurfaceless::Initialize(GLSurface::Format format) {
   if (!SurfacelessEGL::Initialize(format))
     return false;
   vsync_provider_ = ozone_surface_->CreateVSyncProvider();
   if (!vsync_provider_)
     return false;
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::Resize(const gfx::Size& size,
                                        float scale_factor,
@@ skipping 284 matching lines @@
     return;
   }
   GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback);
   current_surface_ ^= 1;
   BindFramebuffer();
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
   if (!context_)
     return;
-  scoped_refptr<gl::GLContext> previous_context = gl::GLContext::GetCurrent();
-  scoped_refptr<gl::GLSurface> previous_surface;
+  scoped_refptr<GLContext> previous_context = GLContext::GetCurrent();
+  scoped_refptr<GLSurface> previous_surface;
 
   bool was_current = previous_context && previous_context->IsCurrent(nullptr) &&
-                     gl::GLSurface::GetCurrent() == this;
+                     GLSurface::GetCurrent() == this;
   if (!was_current) {
     // Only take a reference to previous surface if it's not |this|
     // because otherwise we can take a self reference from our own dtor.
-    previous_surface = gl::GLSurface::GetCurrent();
+    previous_surface = GLSurface::GetCurrent();
     context_->MakeCurrent(this);
   }
 
   glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
   if (fbo_) {
     glDeleteTextures(arraysize(textures_), textures_);
     for (auto& texture : textures_)
       texture = 0;
     glDeleteFramebuffersEXT(1, &fbo_);
     fbo_ = 0;
@@ skipping 184 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gl