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

ui/gl/gl_surface_glx.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_glx.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 #include <memory>
@@ skipping 12 matching lines @@
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/x/x11_connection.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/sync_control_vsync_provider.h"
 
-namespace gfx {
+namespace gl {
 
 namespace {
 
 Display* g_display = nullptr;
 bool g_glx_context_create = false;
 bool g_glx_create_context_robustness_supported = false;
 bool g_glx_texture_from_pixmap_supported = false;
 bool g_glx_oml_sync_control_supported = false;
 
 // Track support of glXGetMscRateOML separately from GLX_OML_sync_control as a
@@ skipping 64 matching lines @@
       found = true;
       break;
     }
   }
   if (found) {
     return configs.get()[i];
   }
   return nullptr;
 }
 
-class OMLSyncControlVSyncProvider
-    : public gfx::SyncControlVSyncProvider {
+class OMLSyncControlVSyncProvider : public gl::SyncControlVSyncProvider {
  public:
   explicit OMLSyncControlVSyncProvider(GLXWindow glx_window)
       : SyncControlVSyncProvider(),
         glx_window_(glx_window) {
   }
 
   ~OMLSyncControlVSyncProvider() override {}
 
  protected:
   bool GetSyncValues(int64_t* system_time,
@@ skipping 86 matching lines @@
 
   void Initialize() {
     DCHECK(display_);
 
     context_ =
         glXCreateNewContext(display_, config_, GLX_RGBA_TYPE, nullptr, True);
 
     DCHECK(nullptr != context_);
   }
 
-  void GetVSyncParameters(const VSyncProvider::UpdateVSyncCallback& callback) {
+  void GetVSyncParameters(
+      const gfx::VSyncProvider::UpdateVSyncCallback& callback) {
     base::TimeTicks now;
     {
       // Don't allow |window_| destruction while we're probing vsync.
       base::AutoLock locked(vsync_lock_);
 
       if (!context_ || cancel_vsync_flag_.IsSet())
         return;
 
       glXMakeContextCurrent(display_, glx_window_, glx_window_, context_);
 
@@ skipping 10 matching lines @@
     const base::TimeDelta kDefaultInterval =
         base::TimeDelta::FromSeconds(1) / 60;
 
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, now, kDefaultInterval));
   }
 
  private:
   // For initialization of display_ in GLSurface::InitializeOneOff before
   // the sandbox goes up.
-  friend class gfx::GLSurfaceGLX;
+  friend class gl::GLSurfaceGLX;
 
   static Display* display_;
 
   GLXFBConfig config_;
   GLXWindow glx_window_;
   GLXContext context_;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   base::CancellationFlag cancel_vsync_flag_;
@@ skipping 23 matching lines @@
       cancel_vsync_flag_->Set();
     }
 
     // Hand-off |shim_| to be deleted on the |vsync_thread_|.
     vsync_thread_->message_loop()->DeleteSoon(
         FROM_HERE,
         shim_.release());
   }
 
   void GetVSyncParameters(
-      const VSyncProvider::UpdateVSyncCallback& callback) override {
+      const gfx::VSyncProvider::UpdateVSyncCallback& callback) override {
     if (kGetVSyncParametersMinSeconds > 0) {
       base::TimeTicks now = base::TimeTicks::Now();
       base::TimeDelta delta = now - last_get_vsync_parameters_time_;
       if (delta.InSeconds() < kGetVSyncParametersMinSeconds)
         return;
       last_get_vsync_parameters_time_ = now;
     }
 
     // Only one outstanding request per surface.
     if (!pending_callback_) {
       pending_callback_.reset(
-          new VSyncProvider::UpdateVSyncCallback(callback));
+          new gfx::VSyncProvider::UpdateVSyncCallback(callback));
       vsync_thread_->message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&SGIVideoSyncProviderThreadShim::GetVSyncParameters,
                      base::Unretained(shim_.get()),
                      base::Bind(
                          &SGIVideoSyncVSyncProvider::PendingCallbackRunner,
                          AsWeakPtr())));
     }
   }
 
  private:
   void PendingCallbackRunner(const base::TimeTicks timebase,
                              const base::TimeDelta interval) {
     DCHECK(pending_callback_);
     pending_callback_->Run(timebase, interval);
     pending_callback_.reset();
   }
 
   scoped_refptr<SGIVideoSyncThread> vsync_thread_;
 
   // Thread shim through which the sync provider is accessed on |vsync_thread_|.
   std::unique_ptr<SGIVideoSyncProviderThreadShim> shim_;
 
-  std::unique_ptr<VSyncProvider::UpdateVSyncCallback> pending_callback_;
+  std::unique_ptr<gfx::VSyncProvider::UpdateVSyncCallback> pending_callback_;
 
   // Raw pointers to sync primitives owned by the shim_.
   // These will only be referenced before we post a task to destroy
   // the shim_, so they are safe to access.
   base::CancellationFlag* cancel_vsync_flag_;
   base::Lock* vsync_lock_;
 
   base::TimeTicks last_get_vsync_parameters_time_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
@@ skipping 199 matching lines @@
 
 gfx::Size NativeViewGLSurfaceGLX::GetSize() {
   return size_;
 }
 
 void* NativeViewGLSurfaceGLX::GetHandle() {
   return reinterpret_cast<void*>(GetDrawableHandle());
 }
 
 bool NativeViewGLSurfaceGLX::SupportsPostSubBuffer() {
-  return gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
+  return gl::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
 }
 
 void* NativeViewGLSurfaceGLX::GetConfig() {
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
 gfx::SwapResult NativeViewGLSurfaceGLX::PostSubBuffer(int x,
                                                       int y,
                                                       int width,
                                                       int height) {
-  DCHECK(gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
+  DCHECK(gl::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return gfx::SwapResult::SWAP_ACK;
 }
 
-VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
+gfx::VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 UnmappedNativeViewGLSurfaceGLX::UnmappedNativeViewGLSurfaceGLX(
     const gfx::Size& size)
     : size_(size), config_(nullptr), window_(0), glx_window_(0) {
@@ skipping 52 matching lines @@
 void* UnmappedNativeViewGLSurfaceGLX::GetConfig() {
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
 UnmappedNativeViewGLSurfaceGLX::~UnmappedNativeViewGLSurfaceGLX() {
   Destroy();
 }
 
-}  // namespace gfx
+}  // namespace gl