Move code in ui/gl/* from 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 85 matching lines @@
 #define EGL_DIRECT_COMPOSITION_ANGLE 0x33A5
 #endif /* EGL_ANGLE_direct_composition */
 
 #ifndef EGL_ANGLE_flexible_surface_compatibility
 #define EGL_ANGLE_flexible_surface_compatibility 1
 #define EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE 0x33A6
 #endif /* EGL_ANGLE_flexible_surface_compatibility */
 
 using ui::GetLastEGLErrorString;
 
-namespace gfx {
+namespace gl {
 
 #if defined(OS_WIN)
 unsigned int NativeViewGLSurfaceEGL::current_swap_generation_ = 0;
 unsigned int NativeViewGLSurfaceEGL::swaps_this_generation_ = 0;
 unsigned int NativeViewGLSurfaceEGL::last_multiswap_generation_ = 0;
 
 const unsigned int MULTISWAP_FRAME_VSYNC_THRESHOLD = 60;
 #endif
 
 namespace {
 
 EGLDisplay g_display;
 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 gfx::SyncControlVSyncProvider {
+class EGLSyncControlVSyncProvider : public gl::SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
       : SyncControlVSyncProvider(),
         surface_(surface) {
   }
 
   ~EGLSyncControlVSyncProvider() override {}
 
  protected:
   bool GetSyncValues(int64_t* system_time,
@@ skipping 340 matching lines @@
 #if defined(OS_ANDROID)
   DCHECK(!g_egl_surfaceless_context_supported);
 #else
   // Check if SurfacelessEGL is supported.
   g_egl_surfaceless_context_supported =
       HasEGLExtension("EGL_KHR_surfaceless_context");
   if (g_egl_surfaceless_context_supported) {
     // EGL_KHR_surfaceless_context is supported but ensure
     // GL_OES_surfaceless_context is also supported. We need a current context
     // to query for supported GL extensions.
-    scoped_refptr<GLSurface> surface = new SurfacelessEGL(Size(1, 1));
+    scoped_refptr<GLSurface> surface = new SurfacelessEGL(gfx::Size(1, 1));
     scoped_refptr<GLContext> context = GLContext::CreateGLContext(
       NULL, surface.get(), PreferIntegratedGpu);
     if (!context->MakeCurrent(surface.get()))
       g_egl_surfaceless_context_supported = false;
 
     // Ensure context supports GL_OES_surfaceless_context.
     if (g_egl_surfaceless_context_supported) {
       g_egl_surfaceless_context_supported = context->HasExtension(
           "GL_OES_surfaceless_context");
       context->ReleaseCurrent(surface.get());
@@ skipping 128 matching lines @@
     size_ = gfx::Rect(windowRect).size();
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize(GLSurface::Format format) {
   format_ = format;
   return Initialize(nullptr);
 }
 
 bool NativeViewGLSurfaceEGL::Initialize(
-    std::unique_ptr<VSyncProvider> sync_provider) {
+    std::unique_ptr<gfx::VSyncProvider> sync_provider) {
   DCHECK(!surface_);
 
   if (!GetDisplay()) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
 
   // We need to make sure that window_ is correctly initialized with all
   // the platform-dependant quirks, if any, before creating the surface.
   if (!InitializeNativeWindow()) {
     LOG(ERROR) << "Error trying to initialize the native window.";
     return false;
   }
 
   std::vector<EGLint> egl_window_attributes;
 
   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 (gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
+  if (gl::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 (gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
+  if (gl::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 171 matching lines @@
 
 gfx::SwapResult NativeViewGLSurfaceEGL::CommitOverlayPlanes() {
   DCHECK(SupportsCommitOverlayPlanes());
   // Here we assume that the overlays scheduled on this surface will display
   // themselves to the screen right away in |CommitAndClearPendingOverlays|,
   // rather than being queued and waiting for a "swap" signal.
   return CommitAndClearPendingOverlays() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
-VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
+gfx::VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
-bool NativeViewGLSurfaceEGL::ScheduleOverlayPlane(int z_order,
-                                                  OverlayTransform transform,
-                                                  gl::GLImage* image,
-                                                  const Rect& bounds_rect,
-                                                  const RectF& crop_rect) {
+bool NativeViewGLSurfaceEGL::ScheduleOverlayPlane(
+    int z_order,
+    gfx::OverlayTransform transform,
+    gl::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 135 matching lines @@
 
 EGLSurface PbufferGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
 void* PbufferGLSurfaceEGL::GetShareHandle() {
 #if defined(OS_ANDROID)
   NOTREACHED();
   return NULL;
 #else
-  if (!gfx::g_driver_egl.ext.b_EGL_ANGLE_query_surface_pointer)
+  if (!gl::g_driver_egl.ext.b_EGL_ANGLE_query_surface_pointer)
     return NULL;
 
-  if (!gfx::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle)
+  if (!gl::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 50 matching lines @@
   return EGL_NO_SURFACE;
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
-}  // namespace gfx
+}  // namespace gl