Move code in ui/gl/* from 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 16 matching lines @@
 #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 gfx {
+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) {
   return eglChooseConfig(display, attribs, configs, config_size, num_configs);
@@ skipping 18 matching lines @@
 
 void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
   eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                        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,
-                    AcceleratedWidget widget);
+                    gfx::AcceleratedWidget widget);
 
   // GLSurface:
-  bool Initialize(gfx::GLSurface::Format format) override;
+  bool Initialize(gl::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,
-                            OverlayTransform transform,
+                            gfx::OverlayTransform transform,
                             GLImage* image,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   EGLConfig GetConfig() override;
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   ~GLSurfaceOzoneEGL() override;
 
   bool ReinitializeNativeSurface();
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
-  AcceleratedWidget widget_;
+  gfx::AcceleratedWidget widget_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL);
 };
 
 GLSurfaceOzoneEGL::GLSurfaceOzoneEGL(
     std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-    AcceleratedWidget widget)
+    gfx::AcceleratedWidget widget)
     : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget) {}
 
-bool GLSurfaceOzoneEGL::Initialize(gfx::GLSurface::Format format) {
+bool GLSurfaceOzoneEGL::Initialize(gl::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))
       return false;
   }
 
   return NativeViewGLSurfaceEGL::Resize(size, scale_factor, has_alpha);
 }
 
 gfx::SwapResult GLSurfaceOzoneEGL::SwapBuffers() {
   gfx::SwapResult result = NativeViewGLSurfaceEGL::SwapBuffers();
   if (result != gfx::SwapResult::SWAP_ACK)
     return result;
 
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
 bool GLSurfaceOzoneEGL::ScheduleOverlayPlane(int z_order,
-                                             OverlayTransform transform,
+                                             gfx::OverlayTransform transform,
                                              GLImage* image,
-                                             const Rect& bounds_rect,
-                                             const RectF& crop_rect) {
+                                             const gfx::Rect& bounds_rect,
+                                             const gfx::RectF& crop_rect) {
   return image->ScheduleOverlayPlane(widget_, z_order, transform, bounds_rect,
                                      crop_rect);
 }
 
 EGLConfig GLSurfaceOzoneEGL::GetConfig() {
   if (!config_) {
     ui::EglConfigCallbacks callbacks = GetEglConfigCallbacks(GetDisplay());
     config_ = ozone_surface_->GetEGLSurfaceConfig(callbacks);
   }
   if (config_)
@@ skipping 27 matching lines @@
     LOG(ERROR) << "Failed to initialize.";
     return false;
   }
 
   return true;
 }
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-                            AcceleratedWidget widget);
+                            gfx::AcceleratedWidget widget);
 
   // GLSurface:
-  bool Initialize(gfx::GLSurface::Format format) override;
+  bool Initialize(gl::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,
-                            OverlayTransform transform,
+                            gfx::OverlayTransform transform,
                             GLImage* image,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   bool IsOffscreen() override;
-  VSyncProvider* GetVSyncProvider() override;
+  gfx::VSyncProvider* GetVSyncProvider() override;
   bool SupportsAsyncSwap() override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
   EGLConfig GetConfig() override;
@@ skipping 14 matching lines @@
   void SubmitFrame();
 
   EGLSyncKHR InsertFence();
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame);
 
   void SwapCompleted(const SwapCompletionCallback& callback,
                      gfx::SwapResult result);
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
-  AcceleratedWidget widget_;
-  std::unique_ptr<VSyncProvider> vsync_provider_;
+  gfx::AcceleratedWidget widget_;
+  std::unique_ptr<gfx::VSyncProvider> vsync_provider_;
   ScopedVector<PendingFrame> unsubmitted_frames_;
   bool has_implicit_external_sync_;
   bool last_swap_buffers_result_;
   bool swap_buffers_pending_;
 
   base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
 GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
 }
 
 GLSurfaceOzoneSurfaceless::GLSurfaceOzoneSurfaceless(
     std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-    AcceleratedWidget widget)
+    gfx::AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       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(gfx::GLSurface::Format format) {
+bool GLSurfaceOzoneSurfaceless::Initialize(gl::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,
                                        bool has_alpha) {
   if (!ozone_surface_->ResizeNativeWindow(size))
     return false;
 
   return SurfacelessEGL::Resize(size, scale_factor, has_alpha);
 }
 
 gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
   glFlush();
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
   if (has_implicit_external_sync_) {
     EGLSyncKHR fence = InsertFence();
     if (!fence)
-      return SwapResult::SWAP_FAILED;
+      return gfx::SwapResult::SWAP_FAILED;
 
     EGLDisplay display = GetDisplay();
     WaitForFence(display, fence);
     eglDestroySyncKHR(display, fence);
   }
 
   unsubmitted_frames_.back()->ScheduleOverlayPlanes(widget_);
   unsubmitted_frames_.back()->overlays.clear();
 
   if (ozone_surface_->IsUniversalDisplayLinkDevice())
     glFinish();
 
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
-bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
-                                                     OverlayTransform transform,
-                                                     GLImage* image,
-                                                     const Rect& bounds_rect,
-                                                     const RectF& crop_rect) {
+bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(
+    int z_order,
+    gfx::OverlayTransform transform,
+    GLImage* image,
+    const gfx::Rect& bounds_rect,
+    const gfx::RectF& crop_rect) {
   unsubmitted_frames_.back()->overlays.push_back(
       GLSurfaceOverlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
   return false;
 }
 
-VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
+gfx::VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 bool GLSurfaceOzoneSurfaceless::SupportsAsyncSwap() {
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::SupportsPostSubBuffer() {
   return true;
 }
@@ skipping 123 matching lines @@
   SubmitFrame();
 }
 
 // This provides surface-like semantics implemented through surfaceless.
 // A framebuffer is bound automatically.
 class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
     : public GLSurfaceOzoneSurfaceless {
  public:
   GLSurfaceOzoneSurfacelessSurfaceImpl(
       std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-      AcceleratedWidget widget);
+      gfx::AcceleratedWidget widget);
 
   // GLSurface:
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult SwapBuffers() override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void Destroy() override;
   bool IsSurfaceless() const override;
 
  private:
   ~GLSurfaceOzoneSurfacelessSurfaceImpl() override;
 
   void BindFramebuffer();
   bool CreatePixmaps();
 
   scoped_refptr<GLContext> context_;
   GLuint fbo_;
   GLuint textures_[2];
   scoped_refptr<GLImage> images_[2];
   int current_surface_;
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl);
 };
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
     std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
-    AcceleratedWidget widget)
+    gfx::AcceleratedWidget widget)
     : GLSurfaceOzoneSurfaceless(std::move(ozone_surface), widget),
       context_(nullptr),
       fbo_(0),
       current_surface_(0) {
   for (auto& texture : textures_)
     texture = 0;
 }
 
 unsigned int
 GLSurfaceOzoneSurfacelessSurfaceImpl::GetBackingFrameBufferObject() {
@@ skipping 26 matching lines @@
   return GLSurfaceOzoneSurfaceless::Resize(size, scale_factor, true) &&
          CreatePixmaps();
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::SupportsPostSubBuffer() {
   return false;
 }
 
 gfx::SwapResult GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffers() {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
-          widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
+          widget_, 0, gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE,
           gfx::Rect(GetSize()), gfx::RectF(1, 1)))
     return gfx::SwapResult::SWAP_FAILED;
   gfx::SwapResult result = GLSurfaceOzoneSurfaceless::SwapBuffers();
   if (result != gfx::SwapResult::SWAP_ACK)
     return result;
   current_surface_ ^= 1;
   BindFramebuffer();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
-          widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
+          widget_, 0, gfx::OverlayTransform::OVERLAY_TRANSFORM_NONE,
           gfx::Rect(GetSize()), gfx::RectF(1, 1))) {
     callback.Run(gfx::SwapResult::SWAP_FAILED);
     return;
   }
   GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback);
   current_surface_ ^= 1;
   BindFramebuffer();
 }
 
 void GLSurfaceOzoneSurfacelessSurfaceImpl::Destroy() {
   if (!context_)
     return;
-  scoped_refptr<gfx::GLContext> previous_context = gfx::GLContext::GetCurrent();
-  scoped_refptr<gfx::GLSurface> previous_surface;
+  scoped_refptr<gl::GLContext> previous_context = gl::GLContext::GetCurrent();
+  scoped_refptr<gl::GLSurface> previous_surface;
 
   bool was_current = previous_context && previous_context->IsCurrent(nullptr) &&
-                     gfx::GLSurface::GetCurrent() == this;
+                     gl::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 = gfx::GLSurface::GetCurrent();
+    previous_surface = gl::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 101 matching lines @@
       return true;
     default:
       return false;
   }
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateSurfacelessViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationEGLGLES2 &&
-      window != kNullAcceleratedWidget &&
+      window != gfx::kNullAcceleratedWidget &&
       GLSurfaceEGL::IsEGLSurfacelessContextSupported()) {
     std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
         ui::OzonePlatform::GetInstance()
             ->GetSurfaceFactoryOzone()
             ->CreateSurfacelessEGLSurfaceForWidget(window);
     if (!surface_ozone)
       return nullptr;
     scoped_refptr<GLSurface> surface;
     surface = new GLSurfaceOzoneSurfaceless(std::move(surface_ozone), window);
     if (surface->Initialize())
       return surface;
   }
 
   return nullptr;
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
     if (!surface->Initialize())
       return nullptr;
     return surface;
   }
-  if ((window != kNullAcceleratedWidget) &&
+  if ((window != gfx::kNullAcceleratedWidget) &&
       (GetGLImplementation() == kGLImplementationEGLGLES2)) {
     scoped_refptr<GLSurface> surface;
     if (GLSurfaceEGL::IsEGLSurfacelessContextSupported())
       surface = CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(window);
     if (!surface)
       surface = CreateViewGLSurfaceOzone(window);
     return surface;
   } else {
     DCHECK_EQ(GetGLImplementation(), kGLImplementationMockGL);
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
@@ skipping 35 matching lines @@
       return nullptr;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
-}  // namespace gfx
+}  // namespace gl