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

gpu/ipc/service/child_window_surface_win.cc

 // Copyright 2015 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/ipc/service/child_window_surface_win.h"
 
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/win/scoped_hdc.h"
@@ skipping 56 matching lines @@
   g_window_class = RegisterClassEx(&intermediate_class);
   if (!g_window_class) {
     LOG(ERROR) << "RegisterClass failed.";
     return;
   }
 }
 }
 
 ChildWindowSurfaceWin::ChildWindowSurfaceWin(GpuChannelManager* manager,
                                              HWND parent_window)
-    : gfx::NativeViewGLSurfaceEGL(0),
+    : gl::NativeViewGLSurfaceEGL(0),
       parent_window_(parent_window),
       manager_(manager),
       alpha_(true),
       first_swap_(true) {
   // Don't use EGL_ANGLE_window_fixed_size so that we can avoid recreating the
   // window surface, which can cause flicker on DirectComposition.
   enable_fixed_size_angle_ = false;
 }
 
 EGLConfig ChildWindowSurfaceWin::GetConfig() {
@@ skipping 47 matching lines @@
 }
 
 bool ChildWindowSurfaceWin::Resize(const gfx::Size& size,
                                    float scale_factor,
                                    bool has_alpha) {
   if (!SupportsPostSubBuffer()) {
     if (!MoveWindow(window_, 0, 0, size.width(), size.height(), FALSE)) {
       return false;
     }
     alpha_ = has_alpha;
-    return gfx::NativeViewGLSurfaceEGL::Resize(size, scale_factor, has_alpha);
+    return gl::NativeViewGLSurfaceEGL::Resize(size, scale_factor, has_alpha);
   } else {
     if (size == GetSize() && has_alpha == alpha_)
       return true;
 
     // Force a resize and redraw (but not a move, activate, etc.).
     if (!SetWindowPos(window_, nullptr, 0, 0, size.width(), size.height(),
                       SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS |
                           SWP_NOOWNERZORDER | SWP_NOZORDER)) {
       return false;
     }
     size_ = size;
     if (has_alpha == alpha_) {
       // A 0-size PostSubBuffer doesn't swap but forces the swap chain to resize
       // to match the window.
       PostSubBuffer(0, 0, 0, 0);
     } else {
       alpha_ = has_alpha;
       config_ = nullptr;
 
       std::unique_ptr<ui::ScopedMakeCurrent> scoped_make_current;
-      gfx::GLContext* current_context = gfx::GLContext::GetCurrent();
+      gl::GLContext* current_context = gl::GLContext::GetCurrent();
       bool was_current = current_context && current_context->IsCurrent(this);
       if (was_current) {
         scoped_make_current.reset(
             new ui::ScopedMakeCurrent(current_context, this));
         current_context->ReleaseCurrent(this);
       }
 
       Destroy();
 
       if (!Initialize()) {
@@ skipping 44 matching lines @@
     rect_to_clear_ = gfx::Rect();
   }
 }
 
 ChildWindowSurfaceWin::~ChildWindowSurfaceWin() {
   gfx::SetWindowUserData(window_, nullptr);
   DestroyWindow(window_);
 }
 
 }  // namespace gpu