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

ui/gl/gl_surface.h

 // 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.
 
 #ifndef UI_GL_GL_SURFACE_H_
 #define UI_GL_GL_SURFACE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_implementation.h"
 
-namespace gl {
-class GLImage;
+namespace gfx {
+class Transform;
+class VSyncProvider;
 }
 
-namespace gfx {
+namespace gl {
 
 class GLContext;
-class Transform;
-class VSyncProvider;
+class GLImage;
 
 // Encapsulates a surface that can be rendered to with GL, hiding platform
 // specific management.
 class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
  public:
   GLSurface();
 
   // Minimum bit depth of surface.
   enum Format {
     SURFACE_ARGB8888,
@@ skipping 45 matching lines @@
   // Returns whether or not the surface supports CommitOverlayPlanes.
   virtual bool SupportsCommitOverlayPlanes();
 
   // Returns whether SwapBuffersAsync() is supported.
   virtual bool SupportsAsyncSwap();
 
   // Returns the internal frame buffer object name if the surface is backed by
   // FBO. Otherwise returns 0.
   virtual unsigned int GetBackingFrameBufferObject();
 
-  typedef base::Callback<void(SwapResult)> SwapCompletionCallback;
+  typedef base::Callback<void(gfx::SwapResult)> SwapCompletionCallback;
   // Swaps front and back buffers. This has no effect for off-screen
   // contexts. On some platforms, we want to send SwapBufferAck only after the
   // surface is displayed on screen. The callback can be used to delay sending
   // SwapBufferAck till that data is available. The callback should be run on
   // the calling thread (i.e. same thread SwapBuffersAsync is called)
   virtual void SwapBuffersAsync(const SwapCompletionCallback& callback);
 
   // Copy part of the backbuffer to the frontbuffer.
   virtual gfx::SwapResult PostSubBuffer(int x, int y, int width, int height);
 
@@ skipping 41 matching lines @@
   virtual void* GetDisplay();
 
   // Get the platfrom specific configuration for this surface, if available.
   virtual void* GetConfig();
 
   // Get the GL pixel format of the surface, if available.
   virtual GLSurface::Format GetFormat();
 
   // Get access to a helper providing time of recent refresh and period
   // of screen refresh. If unavailable, returns NULL.
-  virtual VSyncProvider* GetVSyncProvider();
+  virtual gfx::VSyncProvider* GetVSyncProvider();
 
   // Schedule an overlay plane to be shown at swap time, or on the next
   // CommitOverlayPlanes call.
   // |z_order| specifies the stacking order of the plane relative to the
   // main framebuffer located at index 0. For the case where there is no
   // main framebuffer, overlays may be scheduled at 0, taking its place.
   // |transform| specifies how the buffer is to be transformed during
   // composition.
   // |image| to be presented by the overlay.
   // |bounds_rect| specify where it is supposed to be on the screen in pixels.
   // |crop_rect| specifies the region within the buffer to be placed inside
   // |bounds_rect|.
   virtual bool ScheduleOverlayPlane(int z_order,
-                                    OverlayTransform transform,
+                                    gfx::OverlayTransform transform,
                                     gl::GLImage* image,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect);
+                                    const gfx::Rect& bounds_rect,
+                                    const gfx::RectF& crop_rect);
 
   // Schedule a CALayer to be shown at swap time.
   // All arguments correspond to their CALayer properties.
   virtual bool ScheduleCALayer(gl::GLImage* contents_image,
-                               const RectF& contents_rect,
+                               const gfx::RectF& contents_rect,
                                float opacity,
                                unsigned background_color,
                                unsigned edge_aa_mask,
-                               const RectF& rect,
+                               const gfx::RectF& rect,
                                bool is_clipped,
-                               const RectF& clip_rect,
-                               const Transform& transform,
+                               const gfx::RectF& clip_rect,
+                               const gfx::Transform& transform,
                                int sorting_content_id,
                                unsigned filter);
 
   virtual bool IsSurfaceless() const;
 
   virtual bool FlipsVertically() const;
 
   // Returns true if SwapBuffers or PostSubBuffers causes a flip, such that
   // the next buffer may be 2 frames old.
   virtual bool BuffersFlipped() const;
@@ skipping 75 matching lines @@
   gfx::Size GetSize() override;
   void* GetHandle() override;
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool SetBackbufferAllocation(bool allocated) override;
   void SetFrontbufferAllocation(bool allocated) override;
   void* GetShareHandle() override;
   void* GetDisplay() override;
   void* GetConfig() override;
   GLSurface::Format GetFormat() override;
-  VSyncProvider* GetVSyncProvider() override;
+  gfx::VSyncProvider* GetVSyncProvider() override;
   bool ScheduleOverlayPlane(int z_order,
-                            OverlayTransform transform,
+                            gfx::OverlayTransform transform,
                             gl::GLImage* image,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   bool IsSurfaceless() const override;
   bool FlipsVertically() const override;
   bool BuffersFlipped() const override;
 
   GLSurface* surface() const { return surface_.get(); }
 
  protected:
   ~GLSurfaceAdapter() override;
 
  private:
   scoped_refptr<GLSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceAdapter);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_SURFACE_H_