ui/gl: Move GLImage into gl namespace.

BUG=461575
R=piman@chromium.org,sievers@chromium.org,
TBR=fsamuel@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1421903006

Cr-Commit-Position: refs/heads/master@{#356825}

72 files changed, 380 insertions, 362 deletions

diff --git a/cc/test/test_image_factory.cc b/cc/test/test_image_factory.cc
index 796b6d8..69070e7 100644
--- a/cc/test/test_image_factory.cc
+++ b/cc/test/test_image_factory.cc
@@ -14,7 +14,7 @@ TestImageFactory::TestImageFactory() {
 TestImageFactory::~TestImageFactory() {
 }
 
-scoped_refptr<gfx::GLImage> TestImageFactory::CreateImageForGpuMemoryBuffer(
+scoped_refptr<gl::GLImage> TestImageFactory::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
@@ -22,8 +22,8 @@ scoped_refptr<gfx::GLImage> TestImageFactory::CreateImageForGpuMemoryBuffer(
     int client_id) {
   DCHECK_EQ(handle.type, gfx::SHARED_MEMORY_BUFFER);
 
-  scoped_refptr<gfx::GLImageSharedMemory> image(
-      new gfx::GLImageSharedMemory(size, internalformat));
+  scoped_refptr<gl::GLImageSharedMemory> image(
+      new gl::GLImageSharedMemory(size, internalformat));
   if (!image->Initialize(handle.handle, handle.id, format, handle.offset))
     return nullptr;
 
diff --git a/cc/test/test_image_factory.h b/cc/test/test_image_factory.h
index 88ebe54..3cf0c19 100644
--- a/cc/test/test_image_factory.h
+++ b/cc/test/test_image_factory.h
@@ -15,7 +15,7 @@ class TestImageFactory : public gpu::ImageFactory {
   ~TestImageFactory() override;
 
   // Overridden from gpu::ImageFactory:
-  scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/components/mus/gles2/command_buffer_driver.cc b/components/mus/gles2/command_buffer_driver.cc
index dde7c2c..1eb4930 100644
--- a/components/mus/gles2/command_buffer_driver.cc
+++ b/components/mus/gles2/command_buffer_driver.cc
@@ -249,8 +249,8 @@ void CommandBufferDriver::CreateImage(int32_t id,
   handle = base::FileDescriptor(platform_handle, false);
 #endif
 
-  scoped_refptr<gfx::GLImageSharedMemory> image =
-      new gfx::GLImageSharedMemory(gfx_size, internal_format);
+  scoped_refptr<gl::GLImageSharedMemory> image =
+      new gl::GLImageSharedMemory(gfx_size, internal_format);
   // TODO(jam): also need a mojo enum for this enum
   if (!image->Initialize(handle, gfx::GpuMemoryBufferId(id), gpu_format, 0)) {
     NOTREACHED();
diff --git a/components/mus/gles2/command_buffer_local.cc b/components/mus/gles2/command_buffer_local.cc
index b797da9..429db04 100644
--- a/components/mus/gles2/command_buffer_local.cc
+++ b/components/mus/gles2/command_buffer_local.cc
@@ -137,7 +137,7 @@ int32_t CommandBufferLocal::CreateImage(ClientBuffer buffer,
       MojoGpuMemoryBufferImpl::FromClientBuffer(buffer);
 
   gfx::GpuMemoryBufferHandle handle = gpu_memory_buffer->GetHandle();
-  scoped_refptr<gfx::GLImageSharedMemory> image(new gfx::GLImageSharedMemory(
+  scoped_refptr<gl::GLImageSharedMemory> image(new gl::GLImageSharedMemory(
       gfx::Size(static_cast<int>(width), static_cast<int>(height)),
       internalformat));
   if (!image->Initialize(base::SharedMemory::DuplicateHandle(handle.handle),
diff --git a/content/common/gpu/gpu_channel.cc b/content/common/gpu/gpu_channel.cc
index 2ef4571..746bc11 100644
--- a/content/common/gpu/gpu_channel.cc
+++ b/content/common/gpu/gpu_channel.cc
@@ -1033,15 +1033,15 @@ uint64 GpuChannel::GetMemoryUsage() {
   return size;
 }
 
-scoped_refptr<gfx::GLImage> GpuChannel::CreateImageForGpuMemoryBuffer(
+scoped_refptr<gl::GLImage> GpuChannel::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
     uint32 internalformat) {
   switch (handle.type) {
     case gfx::SHARED_MEMORY_BUFFER: {
-      scoped_refptr<gfx::GLImageSharedMemory> image(
-          new gfx::GLImageSharedMemory(size, internalformat));
+      scoped_refptr<gl::GLImageSharedMemory> image(
+          new gl::GLImageSharedMemory(size, internalformat));
       if (!image->Initialize(handle.handle, handle.id, format, handle.offset))
         return nullptr;
 
diff --git a/content/common/gpu/gpu_channel.h b/content/common/gpu/gpu_channel.h
index 2ca82ee..a47ccf9 100644
--- a/content/common/gpu/gpu_channel.h
+++ b/content/common/gpu/gpu_channel.h
@@ -148,7 +148,7 @@ class CONTENT_EXPORT GpuChannel
 
   uint64 GetMemoryUsage();
 
-  scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/content/common/gpu/gpu_command_buffer_stub.cc b/content/common/gpu/gpu_command_buffer_stub.cc
index 0ae8486..b82d715 100644
--- a/content/common/gpu/gpu_command_buffer_stub.cc
+++ b/content/common/gpu/gpu_command_buffer_stub.cc
@@ -1142,7 +1142,7 @@ void GpuCommandBufferStub::OnCreateImage(int32 id,
     return;
   }
 
-  scoped_refptr<gfx::GLImage> image = channel()->CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> image = channel()->CreateImageForGpuMemoryBuffer(
       handle, size, format, internalformat);
   if (!image.get())
     return;
diff --git a/content/common/gpu/gpu_memory_buffer_factory.h b/content/common/gpu/gpu_memory_buffer_factory.h
index 3054075..80f79fc 100644
--- a/content/common/gpu/gpu_memory_buffer_factory.h
+++ b/content/common/gpu/gpu_memory_buffer_factory.h
@@ -14,10 +14,6 @@
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/native_widget_types.h"
 
-namespace gfx {
-class GLImage;
-}
-
 namespace gpu {
 class ImageFactory;
 }
diff --git a/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc b/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
index b44f714..b9b37f9 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
@@ -218,7 +218,7 @@ gpu::ImageFactory* GpuMemoryBufferFactoryIOSurface::AsImageFactory() {
   return this;
 }
 
-scoped_refptr<gfx::GLImage>
+scoped_refptr<gl::GLImage>
 GpuMemoryBufferFactoryIOSurface::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
@@ -231,12 +231,12 @@ GpuMemoryBufferFactoryIOSurface::CreateImageForGpuMemoryBuffer(
   IOSurfaceMapKey key(handle.id, client_id);
   IOSurfaceMap::iterator it = io_surfaces_.find(key);
   if (it == io_surfaces_.end())
-    return scoped_refptr<gfx::GLImage>();
+    return scoped_refptr<gl::GLImage>();
 
-  scoped_refptr<gfx::GLImageIOSurface> image(
-      new gfx::GLImageIOSurface(size, internalformat));
+  scoped_refptr<gl::GLImageIOSurface> image(
+      new gl::GLImageIOSurface(size, internalformat));
   if (!image->Initialize(it->second.get(), handle.id, format))
-    return scoped_refptr<gfx::GLImage>();
+    return scoped_refptr<gl::GLImage>();
 
   return image;
 }
diff --git a/content/common/gpu/gpu_memory_buffer_factory_io_surface.h b/content/common/gpu/gpu_memory_buffer_factory_io_surface.h
index 05db205..825f48a 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_io_surface.h
+++ b/content/common/gpu/gpu_memory_buffer_factory_io_surface.h
@@ -20,7 +20,7 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -58,7 +58,7 @@ class CONTENT_EXPORT GpuMemoryBufferFactoryIOSurface
   gpu::ImageFactory* AsImageFactory() override;
 
   // Overridden from gpu::ImageFactory:
-  scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.cc b/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.cc
index 0422562..69fdd30 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.cc
@@ -108,7 +108,7 @@ gpu::ImageFactory* GpuMemoryBufferFactoryOzoneNativePixmap::AsImageFactory() {
   return this;
 }
 
-scoped_refptr<gfx::GLImage>
+scoped_refptr<gl::GLImage>
 GpuMemoryBufferFactoryOzoneNativePixmap::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
diff --git a/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h b/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h
index e3b53a2a..4ca2b23 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h
+++ b/content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h
@@ -12,7 +12,7 @@
 #include "gpu/command_buffer/service/image_factory.h"
 #include "ui/ozone/public/native_pixmap.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -47,7 +47,7 @@ class CONTENT_EXPORT GpuMemoryBufferFactoryOzoneNativePixmap
   gpu::ImageFactory* AsImageFactory() override;
 
   // Overridden from gpu::ImageFactory:
-  scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
index 9fb631d..a9913c8 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
@@ -97,7 +97,7 @@ gpu::ImageFactory* GpuMemoryBufferFactorySurfaceTexture::AsImageFactory() {
   return this;
 }
 
-scoped_refptr<gfx::GLImage>
+scoped_refptr<gl::GLImage>
 GpuMemoryBufferFactorySurfaceTexture::CreateImageForGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
@@ -111,12 +111,12 @@ GpuMemoryBufferFactorySurfaceTexture::CreateImageForGpuMemoryBuffer(
   SurfaceTextureMapKey key(handle.id.id, client_id);
   SurfaceTextureMap::iterator it = surface_textures_.find(key);
   if (it == surface_textures_.end())
-    return scoped_refptr<gfx::GLImage>();
+    return scoped_refptr<gl::GLImage>();
 
-  scoped_refptr<gfx::GLImageSurfaceTexture> image(
-      new gfx::GLImageSurfaceTexture(size));
+  scoped_refptr<gl::GLImageSurfaceTexture> image(
+      new gl::GLImageSurfaceTexture(size));
   if (!image->Initialize(it->second.get()))
-    return scoped_refptr<gfx::GLImage>();
+    return scoped_refptr<gl::GLImage>();
 
   return image;
 }
diff --git a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.h b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.h
index 1696df3..b9eda55 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.h
+++ b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.h
@@ -17,10 +17,13 @@
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace gfx {
-class GLImage;
 class SurfaceTexture;
 }
 
+namespace gl {
+class GLImage;
+}
+
 namespace content {
 
 class CONTENT_EXPORT GpuMemoryBufferFactorySurfaceTexture
@@ -52,7 +55,7 @@ class CONTENT_EXPORT GpuMemoryBufferFactorySurfaceTexture
   gpu::ImageFactory* AsImageFactory() override;
 
   // Overridden from gpu::ImageFactory:
-  scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/content/common/gpu/image_transport_surface_overlay_mac.h b/content/common/gpu/image_transport_surface_overlay_mac.h
index c4140f31..9da4adf 100644
--- a/content/common/gpu/image_transport_surface_overlay_mac.h
+++ b/content/common/gpu/image_transport_surface_overlay_mac.h
@@ -42,7 +42,7 @@ class ImageTransportSurfaceOverlayMac : public gfx::GLSurface,
   bool SetBackbufferAllocation(bool allocated) override;
   bool ScheduleOverlayPlane(int z_order,
                             gfx::OverlayTransform transform,
-                            gfx::GLImage* image,
+                            gl::GLImage* image,
                             const gfx::Rect& bounds_rect,
                             const gfx::RectF& crop_rect) override;
   bool IsSurfaceless() const override;
diff --git a/content/common/gpu/image_transport_surface_overlay_mac.mm b/content/common/gpu/image_transport_surface_overlay_mac.mm
index 81dcf54..770c482 100644
--- a/content/common/gpu/image_transport_surface_overlay_mac.mm
+++ b/content/common/gpu/image_transport_surface_overlay_mac.mm
@@ -661,7 +661,7 @@ bool ImageTransportSurfaceOverlayMac::SetBackbufferAllocation(bool allocated) {
 bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
-    gfx::GLImage* image,
+    gl::GLImage* image,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
   DCHECK_EQ(transform, gfx::OVERLAY_TRANSFORM_NONE);
@@ -669,8 +669,8 @@ bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(
     return false;
 
   linked_ptr<OverlayPlane> plane(new OverlayPlane(
-      z_order, static_cast<gfx::GLImageIOSurface*>(image)->io_surface_id().id,
-      static_cast<gfx::GLImageIOSurface*>(image)->io_surface(),
+      z_order, static_cast<gl::GLImageIOSurface*>(image)->io_surface_id().id,
+      static_cast<gl::GLImageIOSurface*>(image)->io_surface(),
       ConvertRectToDIPF(scale_factor_, bounds_rect), crop_rect));
   if (z_order == 0)
     pending_root_plane_ = plane;
diff --git a/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc b/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
index db83791..fd74134 100644
--- a/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
+++ b/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
@@ -84,14 +84,14 @@ AVDACodecImage* AndroidDeferredRenderingBackingStrategy::GetImageForPicture(
     const media::PictureBuffer& picture_buffer) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_NULL_IF_NULL(texture_ref);
-  gfx::GLImage* image =
+  gl::GLImage* image =
       texture_ref->texture()->GetLevelImage(GetTextureTarget(), 0);
   return static_cast<AVDACodecImage*>(image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
     const media::PictureBuffer& picture_buffer,
-    const scoped_refptr<gfx::GLImage>& image) {
+    const scoped_refptr<gl::GLImage>& image) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
@@ -134,7 +134,7 @@ void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
-  scoped_refptr<gfx::GLImage> gl_image(
+  scoped_refptr<gl::GLImage> gl_image(
       new AVDACodecImage(shared_state_, media_codec_,
                          state_provider_->GetGlDecoder(), surface_texture_));
   SetImageForPicture(picture_buffer, gl_image);
diff --git a/content/common/gpu/media/android_deferred_rendering_backing_strategy.h b/content/common/gpu/media/android_deferred_rendering_backing_strategy.h
index 3439a6f..7fb8d2b 100644
--- a/content/common/gpu/media/android_deferred_rendering_backing_strategy.h
+++ b/content/common/gpu/media/android_deferred_rendering_backing_strategy.h
@@ -8,7 +8,7 @@
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/android_video_decode_accelerator.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -59,7 +59,7 @@ class CONTENT_EXPORT AndroidDeferredRenderingBackingStrategy
   // Return the AVDACodecImage for a given PictureBuffer's texture.
   AVDACodecImage* GetImageForPicture(const media::PictureBuffer&);
   void SetImageForPicture(const media::PictureBuffer& picture_buffer,
-                          const scoped_refptr<gfx::GLImage>& image);
+                          const scoped_refptr<gl::GLImage>& image);
 
   scoped_refptr<AVDASharedState> shared_state_;
 
diff --git a/content/common/gpu/media/avda_codec_image.h b/content/common/gpu/media/avda_codec_image.h
index 0ced55c..cba3416 100644
--- a/content/common/gpu/media/avda_codec_image.h
+++ b/content/common/gpu/media/avda_codec_image.h
@@ -12,7 +12,7 @@ namespace content {
 
 // GLImage that renders MediaCodec buffers to a SurfaceTexture as needed
 // in order to draw them.
-class AVDACodecImage : public gfx::GLImage {
+class AVDACodecImage : public gl::GLImage {
  public:
   AVDACodecImage(const scoped_refptr<AVDASharedState>&,
                  media::VideoCodecBridge* codec,
@@ -23,7 +23,7 @@ class AVDACodecImage : public gfx::GLImage {
   ~AVDACodecImage() override;
 
  public:
-  // gfx::GLImage implementation
+  // gl::GLImage implementation
   void Destroy(bool have_context) override;
   gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
diff --git a/content/common/gpu/media/gpu_video_decode_accelerator.cc b/content/common/gpu/media/gpu_video_decode_accelerator.cc
index 9b6e1d7..302caea 100644
--- a/content/common/gpu/media/gpu_video_decode_accelerator.cc
+++ b/content/common/gpu/media/gpu_video_decode_accelerator.cc
@@ -336,7 +336,7 @@ GpuVideoDecodeAccelerator::CreateV4L2SliceVDA() {
 
 void GpuVideoDecodeAccelerator::BindImage(uint32 client_texture_id,
                                           uint32 texture_target,
-                                          scoped_refptr<gfx::GLImage> image) {
+                                          scoped_refptr<gl::GLImage> image) {
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
diff --git a/content/common/gpu/media/gpu_video_decode_accelerator.h b/content/common/gpu/media/gpu_video_decode_accelerator.h
index e4c85b1..2b2c3b7 100644
--- a/content/common/gpu/media/gpu_video_decode_accelerator.h
+++ b/content/common/gpu/media/gpu_video_decode_accelerator.h
@@ -108,7 +108,7 @@ class GpuVideoDecodeAccelerator
   // Helper to bind |image| to the texture specified by |client_texture_id|.
   void BindImage(uint32 client_texture_id,
                  uint32 texture_target,
-                 scoped_refptr<gfx::GLImage> image);
+                 scoped_refptr<gl::GLImage> image);
 
   // Route ID to communicate with the host.
   const int32 host_route_id_;
diff --git a/content/common/gpu/media/vaapi_drm_picture.cc b/content/common/gpu/media/vaapi_drm_picture.cc
index 6d16a0f..55d01d4 100644
--- a/content/common/gpu/media/vaapi_drm_picture.cc
+++ b/content/common/gpu/media/vaapi_drm_picture.cc
@@ -191,7 +191,7 @@ scoped_refptr<ui::NativePixmap> VaapiDrmPicture::ScalePixmap(
   return scaled_pixmap_;
 }
 
-scoped_refptr<gfx::GLImage> VaapiDrmPicture::GetImageToBind() {
+scoped_refptr<gl::GLImage> VaapiDrmPicture::GetImageToBind() {
   return gl_image_;
 }
 
diff --git a/content/common/gpu/media/vaapi_drm_picture.h b/content/common/gpu/media/vaapi_drm_picture.h
index 4a0b83b..4ea787f 100644
--- a/content/common/gpu/media/vaapi_drm_picture.h
+++ b/content/common/gpu/media/vaapi_drm_picture.h
@@ -15,7 +15,7 @@
 #include "content/common/gpu/media/vaapi_picture.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -42,7 +42,7 @@ class VaapiDrmPicture : public VaapiPicture {
 
   bool DownloadFromSurface(const scoped_refptr<VASurface>& va_surface) override;
 
-  scoped_refptr<gfx::GLImage> GetImageToBind() override;
+  scoped_refptr<gl::GLImage> GetImageToBind() override;
 
   bool AllowOverlay() const override;
 
@@ -69,7 +69,7 @@ class VaapiDrmPicture : public VaapiPicture {
   scoped_refptr<ui::NativePixmap> scaled_pixmap_;
 
   // EGLImage bound to the GL textures used by the VDA client.
-  scoped_refptr<gfx::GLImage> gl_image_;
+  scoped_refptr<gl::GLImage> gl_image_;
 
   // VASurface used to transfer from the decoder's pixel format.
   scoped_refptr<VASurface> va_surface_;
diff --git a/content/common/gpu/media/vaapi_picture.h b/content/common/gpu/media/vaapi_picture.h
index ad43dfa..c1fb4c5b 100644
--- a/content/common/gpu/media/vaapi_picture.h
+++ b/content/common/gpu/media/vaapi_picture.h
@@ -16,7 +16,7 @@
 #include "base/threading/non_thread_safe.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -40,7 +40,7 @@ class VaapiPicture : public base::NonThreadSafe {
   virtual bool AllowOverlay() const;
 
   // Returns the |GLImage|, if any, to bind to the texture.
-  virtual scoped_refptr<gfx::GLImage> GetImageToBind() = 0;
+  virtual scoped_refptr<gl::GLImage> GetImageToBind() = 0;
 
   // Downloads the |va_surface| into the picture, potentially scaling
   // it if needed.
diff --git a/content/common/gpu/media/vaapi_tfp_picture.cc b/content/common/gpu/media/vaapi_tfp_picture.cc
index ee03742..7dbd139 100644
--- a/content/common/gpu/media/vaapi_tfp_picture.cc
+++ b/content/common/gpu/media/vaapi_tfp_picture.cc
@@ -52,7 +52,7 @@ bool VaapiTFPPicture::Initialize() {
     return false;
   }
 
-  glx_image_ = new gfx::GLImageGLX(size(), GL_RGB);
+  glx_image_ = new gl::GLImageGLX(size(), GL_RGB);
   if (!glx_image_->Initialize(x_pixmap_)) {
     // x_pixmap_ will be freed in the destructor.
     LOG(ERROR) << "Failed creating a GLX Pixmap for TFP";
@@ -74,7 +74,7 @@ bool VaapiTFPPicture::DownloadFromSurface(
                                               va_surface->size());
 }
 
-scoped_refptr<gfx::GLImage> VaapiTFPPicture::GetImageToBind() {
+scoped_refptr<gl::GLImage> VaapiTFPPicture::GetImageToBind() {
   return nullptr;
 }
 
diff --git a/content/common/gpu/media/vaapi_tfp_picture.h b/content/common/gpu/media/vaapi_tfp_picture.h
index 3261791..fdc2c64 100644
--- a/content/common/gpu/media/vaapi_tfp_picture.h
+++ b/content/common/gpu/media/vaapi_tfp_picture.h
@@ -16,10 +16,13 @@
 #include "ui/gl/gl_bindings.h"
 
 namespace gfx {
-class GLImageGLX;
 class GLContextGLX;
 }
 
+namespace gl {
+class GLImageGLX;
+}
+
 namespace content {
 
 class VaapiWrapper;
@@ -39,7 +42,7 @@ class VaapiTFPPicture : public VaapiPicture {
 
   bool DownloadFromSurface(const scoped_refptr<VASurface>& va_surface) override;
 
-  scoped_refptr<gfx::GLImage> GetImageToBind() override;
+  scoped_refptr<gl::GLImage> GetImageToBind() override;
 
  private:
   VaapiWrapper* vaapi_wrapper_;  // Not owned.
@@ -48,7 +51,7 @@ class VaapiTFPPicture : public VaapiPicture {
   Display* x_display_;
 
   Pixmap x_pixmap_;
-  scoped_refptr<gfx::GLImageGLX> glx_image_;
+  scoped_refptr<gl::GLImageGLX> glx_image_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiTFPPicture);
 };
diff --git a/content/common/gpu/media/vaapi_video_decode_accelerator.cc b/content/common/gpu/media/vaapi_video_decode_accelerator.cc
index b0ecbd0..d5b70aa 100644
--- a/content/common/gpu/media/vaapi_video_decode_accelerator.cc
+++ b/content/common/gpu/media/vaapi_video_decode_accelerator.cc
@@ -291,7 +291,7 @@ VaapiPicture* VaapiVideoDecodeAccelerator::PictureById(
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     const base::Callback<bool(void)>& make_context_current,
-    const base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)>&
+    const base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)>&
         bind_image)
     : make_context_current_(make_context_current),
       state_(kUninitialized),
@@ -732,7 +732,7 @@ void VaapiVideoDecodeAccelerator::AssignPictureBuffers(
         vaapi_wrapper_.get(), make_context_current_, buffers[i].id(),
         buffers[i].texture_id(), requested_pic_size_));
 
-    scoped_refptr<gfx::GLImage> image = picture->GetImageToBind();
+    scoped_refptr<gl::GLImage> image = picture->GetImageToBind();
     if (image) {
       bind_image_.Run(buffers[i].internal_texture_id(),
                       VaapiPicture::GetGLTextureTarget(), image);
diff --git a/content/common/gpu/media/vaapi_video_decode_accelerator.h b/content/common/gpu/media/vaapi_video_decode_accelerator.h
index fe92938..ac9f4be 100644
--- a/content/common/gpu/media/vaapi_video_decode_accelerator.h
+++ b/content/common/gpu/media/vaapi_video_decode_accelerator.h
@@ -28,7 +28,7 @@
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -52,7 +52,7 @@ class CONTENT_EXPORT VaapiVideoDecodeAccelerator
 
   VaapiVideoDecodeAccelerator(
       const base::Callback<bool(void)>& make_context_current,
-      const base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)>&
+      const base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)>&
           bind_image);
   ~VaapiVideoDecodeAccelerator() override;
 
@@ -303,7 +303,7 @@ class CONTENT_EXPORT VaapiVideoDecodeAccelerator
 
   // Binds the provided GLImage to a givenr client texture ID & texture target
   // combination in GLES.
-  base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)> bind_image_;
+  base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)> bind_image_;
 
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<VaapiVideoDecodeAccelerator> weak_this_factory_;
diff --git a/content/common/gpu/media/video_decode_accelerator_unittest.cc b/content/common/gpu/media/video_decode_accelerator_unittest.cc
index 493ced7..9a8b774 100644
--- a/content/common/gpu/media/video_decode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_decode_accelerator_unittest.cc
@@ -367,7 +367,7 @@ class GLRenderingVDAClient
 
   void BindImage(uint32 client_texture_id,
                  uint32 texture_target,
-                 scoped_refptr<gfx::GLImage> image);
+                 scoped_refptr<gl::GLImage> image);
 
   void SetState(ClientState new_state);
   void FinishInitialization();
@@ -576,8 +576,7 @@ GLRenderingVDAClient::CreateVaapiVDA() {
 
 void GLRenderingVDAClient::BindImage(uint32 client_texture_id,
                                      uint32 texture_target,
-                                     scoped_refptr<gfx::GLImage> image) {
-}
+                                     scoped_refptr<gl::GLImage> image) {}
 
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   LOG_ASSERT(decoder_deleted());
diff --git a/content/common/gpu/media/vt_video_decode_accelerator.cc b/content/common/gpu/media/vt_video_decode_accelerator.cc
index 076c9dc..2947fe1 100644
--- a/content/common/gpu/media/vt_video_decode_accelerator.cc
+++ b/content/common/gpu/media/vt_video_decode_accelerator.cc
@@ -300,7 +300,7 @@ bool VTVideoDecodeAccelerator::FrameOrder::operator()(
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
     const base::Callback<bool(void)>& make_context_current,
-    const base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)>&
+    const base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)>&
         bind_image)
     : make_context_current_(make_context_current),
       bind_image_(bind_image),
@@ -1044,8 +1044,8 @@ bool VTVideoDecodeAccelerator::SendFrame(const Frame& frame) {
   }
 
   bool allow_overlay = false;
-  scoped_refptr<gfx::GLImageIOSurface> gl_image(
-      new gfx::GLImageIOSurface(frame.coded_size, GL_BGRA_EXT));
+  scoped_refptr<gl::GLImageIOSurface> gl_image(
+      new gl::GLImageIOSurface(frame.coded_size, GL_BGRA_EXT));
   if (gl_image->Initialize(surface, gfx::GenericSharedMemoryId(),
                            gfx::BufferFormat::BGRA_8888)) {
     allow_overlay = true;
diff --git a/content/common/gpu/media/vt_video_decode_accelerator.h b/content/common/gpu/media/vt_video_decode_accelerator.h
index 0a38509..c728968 100644
--- a/content/common/gpu/media/vt_video_decode_accelerator.h
+++ b/content/common/gpu/media/vt_video_decode_accelerator.h
@@ -36,7 +36,7 @@ class VTVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
  public:
   explicit VTVideoDecodeAccelerator(
       const base::Callback<bool(void)>& make_context_current,
-      const base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)>&
+      const base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)>&
           bind_image);
   ~VTVideoDecodeAccelerator() override;
 
@@ -127,7 +127,7 @@ class VTVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
     // The GLImage representation of |cv_image|. This is kept around to ensure
     // that Destroy is called on it before it hits its destructor (there is a
     // DCHECK that requires this).
-    scoped_refptr<gfx::GLImageIOSurface> gl_image;
+    scoped_refptr<gl::GLImageIOSurface> gl_image;
 
     // Texture IDs for the image buffer.
     const uint32_t client_texture_id;
@@ -187,7 +187,7 @@ class VTVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
   // GPU thread state.
   //
   base::Callback<bool(void)> make_context_current_;
-  base::Callback<void(uint32, uint32, scoped_refptr<gfx::GLImage>)> bind_image_;
+  base::Callback<void(uint32, uint32, scoped_refptr<gl::GLImage>)> bind_image_;
   media::VideoDecodeAccelerator::Client* client_;
   State state_;
 
diff --git a/content/common/gpu/stream_texture_android.cc b/content/common/gpu/stream_texture_android.cc
index daac127..84a0d1f 100644
--- a/content/common/gpu/stream_texture_android.cc
+++ b/content/common/gpu/stream_texture_android.cc
@@ -38,7 +38,7 @@ bool StreamTexture::Create(
 
     // TODO: Ideally a valid image id was returned to the client so that
     // it could then call glBindTexImage2D() for doing the following.
-    scoped_refptr<gfx::GLImage> gl_image(
+    scoped_refptr<gl::GLImage> gl_image(
         new StreamTexture(owner_stub, stream_id, texture->service_id()));
     gfx::Size size = gl_image->GetSize();
     texture_manager->SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
diff --git a/content/common/gpu/stream_texture_android.h b/content/common/gpu/stream_texture_android.h
index 94a0848..a761206 100644
--- a/content/common/gpu/stream_texture_android.h
+++ b/content/common/gpu/stream_texture_android.h
@@ -18,7 +18,7 @@ class Size;
 
 namespace content {
 
-class StreamTexture : public gfx::GLImage,
+class StreamTexture : public gl::GLImage,
                       public IPC::Listener,
                       public GpuCommandBufferStub::DestructionObserver {
  public:
@@ -32,7 +32,7 @@ class StreamTexture : public gfx::GLImage,
                 uint32 texture_id);
   ~StreamTexture() override;
 
-  // gfx::GLImage implementation:
+  // gl::GLImage implementation:
   void Destroy(bool have_context) override;
   gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 0ecf45b..6095b84 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -1896,7 +1896,7 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
 
   // Copies the image to the texture currently bound to |textarget|. The image
   // state of |texture| is updated to reflect the new state.
-  void DoCopyTexImage(Texture* texture, GLenum textarget, gfx::GLImage* image);
+  void DoCopyTexImage(Texture* texture, GLenum textarget, gl::GLImage* image);
 
   // This will call DoCopyTexImage if texture has an image but that image is
   // not bound or copied to the texture.
@@ -7532,7 +7532,7 @@ void GLES2DecoderImpl::PerformanceWarning(
 
 void GLES2DecoderImpl::DoCopyTexImage(Texture* texture,
                                       GLenum textarget,
-                                      gfx::GLImage* image) {
+                                      gl::GLImage* image) {
   // Note: We update the state to COPIED prior to calling CopyTexImage()
   // as that allows the GLImage implemenatation to set it back to UNBOUND
   // and ensure that CopyTexImage() is called each time the texture is
@@ -7547,7 +7547,7 @@ void GLES2DecoderImpl::DoCopyTexImageIfNeeded(Texture* texture,
   // Image is already in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
     Texture::ImageState image_state;
-    gfx::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
+    gl::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
     if (image && image_state == Texture::UNBOUND) {
       ScopedGLErrorSuppressor suppressor(
           "GLES2DecoderImpl::DoCopyTexImageIfNeeded", GetErrorState());
@@ -7601,7 +7601,7 @@ bool GLES2DecoderImpl::PrepareTexturesForRender() {
         if (textarget != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
           Texture::ImageState image_state;
-          gfx::GLImage* image =
+          gl::GLImage* image =
               texture->GetLevelImage(textarget, 0, &image_state);
           if (image && image_state == Texture::UNBOUND &&
               !texture->IsAttachedToFramebuffer()) {
@@ -9366,7 +9366,7 @@ error::Error GLES2DecoderImpl::HandleScheduleOverlayPlaneCHROMIUM(
     return error::kNoError;
   }
   Texture::ImageState image_state;
-  gfx::GLImage* image =
+  gl::GLImage* image =
       ref->texture()->GetLevelImage(ref->texture()->target(), 0, &image_state);
   if (!image || image_state != Texture::BOUND) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
@@ -12854,7 +12854,7 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
-  gfx::GLImage* image =
+  gl::GLImage* image =
       source_texture->GetLevelImage(source_texture->target(), 0);
   if (image) {
     gfx::Size size = image->GetSize();
@@ -13012,7 +13012,7 @@ void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
-  gfx::GLImage* image =
+  gl::GLImage* image =
       source_texture->GetLevelImage(source_texture->target(), 0);
   if (image) {
     gfx::Size size = image->GetSize();
@@ -13158,7 +13158,7 @@ void GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM(GLenum target,
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
-  gfx::GLImage* image =
+  gl::GLImage* image =
       source_texture->GetLevelImage(source_texture->target(), 0);
   if (image) {
     gfx::Size size = image->GetSize();
@@ -13334,7 +13334,7 @@ void GLES2DecoderImpl::DoCompressedCopySubTextureCHROMIUM(GLenum target,
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
-  gfx::GLImage* image =
+  gl::GLImage* image =
       source_texture->GetLevelImage(source_texture->target(), 0);
   if (image) {
     gfx::Size size = image->GetSize();
@@ -13939,7 +13939,7 @@ void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
     return;
   }
 
-  gfx::GLImage* image = image_manager()->LookupImage(image_id);
+  gl::GLImage* image = image_manager()->LookupImage(image_id);
   if (!image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ -13982,7 +13982,7 @@ void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
     return;
   }
 
-  gfx::GLImage* image = image_manager()->LookupImage(image_id);
+  gl::GLImage* image = image_manager()->LookupImage(image_id);
   if (!image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index 37d377d..7c7cf7c 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -2611,7 +2611,7 @@ TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
 
@@ -2647,7 +2647,7 @@ TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
 }
 
 TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
 
@@ -2658,7 +2658,7 @@ TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
 }
 
 TEST_P(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
@@ -2681,7 +2681,7 @@ TEST_P(GLES2DecoderTest, GLImageAttachedAfterSubTexImage2D) {
   ASSERT_FALSE(
       feature_info()->workarounds().texsubimage_faster_than_teximage);
 
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
@@ -2726,7 +2726,7 @@ TEST_P(GLES2DecoderTest, GLImageAttachedAfterSubTexImage2D) {
 }
 
 TEST_P(GLES2DecoderTest, GLImageAttachedAfterClearLevel) {
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
@@ -2779,7 +2779,7 @@ TEST_P(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   GetImageManager()->AddImage(image.get(), 1);
   EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
 
@@ -2820,11 +2820,11 @@ TEST_P(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 }
 
-class MockGLImage : public gfx::GLImage {
+class MockGLImage : public gl::GLImage {
  public:
   MockGLImage() {}
 
-  // Overridden from gfx::GLImage:
+  // Overridden from gl::GLImage:
   MOCK_METHOD0(GetSize, gfx::Size());
   MOCK_METHOD0(GetInternalFormat, unsigned());
   MOCK_METHOD1(Destroy, void(bool));
diff --git a/gpu/command_buffer/service/image_factory.h b/gpu/command_buffer/service/image_factory.h
index 3746d56..c27c245 100644
--- a/gpu/command_buffer/service/image_factory.h
+++ b/gpu/command_buffer/service/image_factory.h
@@ -10,7 +10,7 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -44,7 +44,7 @@ class GPU_EXPORT ImageFactory {
   // Creates a GLImage instance for GPU memory buffer identified by |handle|.
   // |client_id| should be set to the client requesting the creation of instance
   // and can be used by factory implementation to verify access rights.
-  virtual scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
+  virtual scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
diff --git a/gpu/command_buffer/service/image_manager.cc b/gpu/command_buffer/service/image_manager.cc
index 46438c7..7464734 100644
--- a/gpu/command_buffer/service/image_manager.cc
+++ b/gpu/command_buffer/service/image_manager.cc
@@ -23,7 +23,7 @@ void ImageManager::Destroy(bool have_context) {
   images_.clear();
 }
 
-void ImageManager::AddImage(gfx::GLImage* image, int32 service_id) {
+void ImageManager::AddImage(gl::GLImage* image, int32 service_id) {
   DCHECK(images_.find(service_id) == images_.end());
   images_[service_id] = image;
 }
@@ -35,7 +35,7 @@ void ImageManager::RemoveImage(int32 service_id) {
   images_.erase(iter);
 }
 
-gfx::GLImage* ImageManager::LookupImage(int32 service_id) {
+gl::GLImage* ImageManager::LookupImage(int32 service_id) {
   GLImageMap::const_iterator iter = images_.find(service_id);
   if (iter != images_.end())
     return iter->second.get();
diff --git a/gpu/command_buffer/service/image_manager.h b/gpu/command_buffer/service/image_manager.h
index 0a440f9e..8ec1e3f 100644
--- a/gpu/command_buffer/service/image_manager.h
+++ b/gpu/command_buffer/service/image_manager.h
@@ -10,7 +10,7 @@
 #include "base/memory/ref_counted.h"
 #include "gpu/gpu_export.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -24,12 +24,12 @@ class GPU_EXPORT ImageManager {
   ~ImageManager();
 
   void Destroy(bool have_context);
-  void AddImage(gfx::GLImage* image, int32 service_id);
+  void AddImage(gl::GLImage* image, int32 service_id);
   void RemoveImage(int32 service_id);
-  gfx::GLImage* LookupImage(int32 service_id);
+  gl::GLImage* LookupImage(int32 service_id);
 
  private:
-  typedef base::hash_map<int32, scoped_refptr<gfx::GLImage> > GLImageMap;
+  typedef base::hash_map<int32, scoped_refptr<gl::GLImage>> GLImageMap;
   GLImageMap images_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageManager);
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index 77647ef..3b5f9d0 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -712,8 +712,8 @@ void InProcessCommandBuffer::CreateImageOnGpuThread(
 
   switch (handle.type) {
     case gfx::SHARED_MEMORY_BUFFER: {
-      scoped_refptr<gfx::GLImageSharedMemory> image(
-          new gfx::GLImageSharedMemory(size, internalformat));
+      scoped_refptr<gl::GLImageSharedMemory> image(
+          new gl::GLImageSharedMemory(size, internalformat));
       if (!image->Initialize(handle.handle, handle.id, format, handle.offset)) {
         LOG(ERROR) << "Failed to initialize image.";
         return;
@@ -731,7 +731,7 @@ void InProcessCommandBuffer::CreateImageOnGpuThread(
       // Note: this assumes that client ID is always 0.
       const int kClientId = 0;
 
-      scoped_refptr<gfx::GLImage> image =
+      scoped_refptr<gl::GLImage> image =
           image_factory_->CreateImageForGpuMemoryBuffer(
               handle, size, format, internalformat, kClientId);
       if (!image.get()) {
diff --git a/gpu/command_buffer/service/mailbox_manager_sync.cc b/gpu/command_buffer/service/mailbox_manager_sync.cc
index 94aa1d7..8391450 100644
--- a/gpu/command_buffer/service/mailbox_manager_sync.cc
+++ b/gpu/command_buffer/service/mailbox_manager_sync.cc
@@ -273,7 +273,7 @@ void MailboxManagerSync::UpdateDefinitionLocked(
   if (SkipTextureWorkarounds(texture))
     return;
 
-  gfx::GLImage* image = texture->GetLevelImage(texture->target(), 0);
+  gl::GLImage* image = texture->GetLevelImage(texture->target(), 0);
   TextureGroup* group = group_ref->group.get();
   const TextureDefinition& definition = group->GetDefinition();
   scoped_refptr<NativeImageBuffer> image_buffer = definition.image();
diff --git a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
index 40908a8..7cf814a 100644
--- a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
+++ b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
@@ -17,14 +17,14 @@ namespace gpu {
 namespace {
 
 // Simply wraps a SurfaceTexture reference as a GLImage.
-class GLImageImpl : public gfx::GLImage {
+class GLImageImpl : public gl::GLImage {
  public:
   GLImageImpl(uint32 texture_id,
               gles2::TextureManager* texture_manager,
               const scoped_refptr<gfx::SurfaceTexture>& surface_texture,
               const base::Closure& release_callback);
 
-  // implement gfx::GLImage
+  // implement gl::GLImage
   void Destroy(bool have_context) override;
   gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
@@ -168,7 +168,7 @@ GLuint StreamTextureManagerInProcess::CreateStreamTexture(
   base::Closure release_callback =
       base::Bind(&StreamTextureManagerInProcess::OnReleaseStreamTexture,
                  weak_factory_.GetWeakPtr(), stream_id);
-  scoped_refptr<gfx::GLImage> gl_image(
+  scoped_refptr<gl::GLImage> gl_image(
       new GLImageImpl(texture->service_id(), texture_manager, surface_texture,
                       release_callback));
 
diff --git a/gpu/command_buffer/service/texture_definition.cc b/gpu/command_buffer/service/texture_definition.cc
index 3f16e85..ed3e8b6 100644
--- a/gpu/command_buffer/service/texture_definition.cc
+++ b/gpu/command_buffer/service/texture_definition.cc
@@ -25,7 +25,7 @@ namespace gles2 {
 
 namespace {
 
-class GLImageSync : public gfx::GLImage {
+class GLImageSync : public gl::GLImage {
  public:
   explicit GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer,
                        const gfx::Size& size);
@@ -124,9 +124,9 @@ class NativeImageBufferEGL : public NativeImageBuffer {
  private:
   NativeImageBufferEGL(EGLDisplay display, EGLImageKHR image);
   ~NativeImageBufferEGL() override;
-  void AddClient(gfx::GLImage* client) override;
-  void RemoveClient(gfx::GLImage* client) override;
-  bool IsClient(gfx::GLImage* client) override;
+  void AddClient(gl::GLImage* client) override;
+  void RemoveClient(gl::GLImage* client) override;
+  bool IsClient(gl::GLImage* client) override;
   void BindToTexture(GLenum target) const override;
 
   const EGLDisplay egl_display_;
@@ -135,14 +135,14 @@ class NativeImageBufferEGL : public NativeImageBuffer {
   base::Lock lock_;
 
   struct ClientInfo {
-    explicit ClientInfo(gfx::GLImage* client);
+    explicit ClientInfo(gl::GLImage* client);
     ~ClientInfo();
 
-    gfx::GLImage* client;
+    gl::GLImage* client;
     bool needs_wait_before_read;
   };
   std::list<ClientInfo> client_infos_;
-  gfx::GLImage* write_client_;
+  gl::GLImage* write_client_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferEGL);
 };
@@ -177,7 +177,7 @@ scoped_refptr<NativeImageBufferEGL> NativeImageBufferEGL::Create(
   return new NativeImageBufferEGL(egl_display, egl_image);
 }
 
-NativeImageBufferEGL::ClientInfo::ClientInfo(gfx::GLImage* client)
+NativeImageBufferEGL::ClientInfo::ClientInfo(gl::GLImage* client)
     : client(client), needs_wait_before_read(true) {}
 
 NativeImageBufferEGL::ClientInfo::~ClientInfo() {}
@@ -198,12 +198,12 @@ NativeImageBufferEGL::~NativeImageBufferEGL() {
     eglDestroyImageKHR(egl_display_, egl_image_);
 }
 
-void NativeImageBufferEGL::AddClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::AddClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   client_infos_.push_back(ClientInfo(client));
 }
 
-void NativeImageBufferEGL::RemoveClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::RemoveClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   if (write_client_ == client)
     write_client_ = NULL;
@@ -218,7 +218,7 @@ void NativeImageBufferEGL::RemoveClient(gfx::GLImage* client) {
   NOTREACHED();
 }
 
-bool NativeImageBufferEGL::IsClient(gfx::GLImage* client) {
+bool NativeImageBufferEGL::IsClient(gl::GLImage* client) {
   base::AutoLock lock(lock_);
   for (std::list<ClientInfo>::iterator it = client_infos_.begin();
        it != client_infos_.end();
@@ -244,9 +244,9 @@ class NativeImageBufferStub : public NativeImageBuffer {
 
  private:
   ~NativeImageBufferStub() override {}
-  void AddClient(gfx::GLImage* client) override {}
-  void RemoveClient(gfx::GLImage* client) override {}
-  bool IsClient(gfx::GLImage* client) override { return true; }
+  void AddClient(gl::GLImage* client) override {}
+  void RemoveClient(gl::GLImage* client) override {}
+  bool IsClient(gl::GLImage* client) override { return true; }
   void BindToTexture(GLenum target) const override {}
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
@@ -342,10 +342,9 @@ TextureDefinition::TextureDefinition(
 
   const Texture::FaceInfo& first_face = texture->face_infos_[0];
   if (image_buffer_.get()) {
-    scoped_refptr<gfx::GLImage> gl_image(
-        new GLImageSync(image_buffer_,
-                        gfx::Size(first_face.level_infos[0].width,
-                                  first_face.level_infos[0].height)));
+    scoped_refptr<gl::GLImage> gl_image(new GLImageSync(
+        image_buffer_, gfx::Size(first_face.level_infos[0].width,
+                                 first_face.level_infos[0].height)));
     texture->SetLevelImage(target_, 0, gl_image.get(), Texture::BOUND);
   }
 
@@ -376,7 +375,7 @@ void TextureDefinition::UpdateTextureInternal(Texture* texture) const {
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t_);
 
   if (image_buffer_.get()) {
-    gfx::GLImage* existing_image = texture->GetLevelImage(target_, 0);
+    gl::GLImage* existing_image = texture->GetLevelImage(target_, 0);
     // Don't need to re-bind if already bound before.
     if (!existing_image || !image_buffer_->IsClient(existing_image)) {
       image_buffer_->BindToTexture(target_);
diff --git a/gpu/command_buffer/service/texture_definition.h b/gpu/command_buffer/service/texture_definition.h
index 9426fc4..bc1393c 100644
--- a/gpu/command_buffer/service/texture_definition.h
+++ b/gpu/command_buffer/service/texture_definition.h
@@ -11,7 +11,7 @@
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
 }
 
@@ -24,9 +24,9 @@ class NativeImageBuffer : public base::RefCountedThreadSafe<NativeImageBuffer> {
  public:
   static scoped_refptr<NativeImageBuffer> Create(GLuint texture_id);
 
-  virtual void AddClient(gfx::GLImage* client) = 0;
-  virtual void RemoveClient(gfx::GLImage* client) = 0;
-  virtual bool IsClient(gfx::GLImage* client) = 0;
+  virtual void AddClient(gl::GLImage* client) = 0;
+  virtual void RemoveClient(gl::GLImage* client) = 0;
+  virtual bool IsClient(gl::GLImage* client) = 0;
   virtual void BindToTexture(GLenum target) const = 0;
 
  protected:
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index ec0aec1..d883622 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -1240,7 +1240,7 @@ bool Texture::ClearLevel(
 
 void Texture::SetLevelImage(GLenum target,
                             GLint level,
-                            gfx::GLImage* image,
+                            gl::GLImage* image,
                             ImageState state) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
@@ -1258,9 +1258,9 @@ void Texture::SetLevelImage(GLenum target,
   UpdateHasImages();
 }
 
-gfx::GLImage* Texture::GetLevelImage(GLint target,
-                                     GLint level,
-                                     ImageState* state) const {
+gl::GLImage* Texture::GetLevelImage(GLint target,
+                                    GLint level,
+                                    ImageState* state) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
@@ -1279,7 +1279,7 @@ gfx::GLImage* Texture::GetLevelImage(GLint target,
   return NULL;
 }
 
-gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
+gl::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   return GetLevelImage(target, level, nullptr);
 }
 
@@ -1725,7 +1725,7 @@ GLsizei TextureManager::ComputeMipMapCount(GLenum target,
 void TextureManager::SetLevelImage(TextureRef* ref,
                                    GLenum target,
                                    GLint level,
-                                   gfx::GLImage* image,
+                                   gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(target, level, image, state);
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index 62b81d2..a18e278 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -152,15 +152,15 @@ class GPU_EXPORT Texture {
   // Set the image for a particular level.
   void SetLevelImage(GLenum target,
                      GLint level,
-                     gfx::GLImage* image,
+                     gl::GLImage* image,
                      ImageState state);
 
   // Get the image associated with a particular level. Returns NULL if level
   // does not exist.
-  gfx::GLImage* GetLevelImage(GLint target,
-                              GLint level,
-                              ImageState* state) const;
-  gfx::GLImage* GetLevelImage(GLint target, GLint level) const;
+  gl::GLImage* GetLevelImage(GLint target,
+                             GLint level,
+                             ImageState* state) const;
+  gl::GLImage* GetLevelImage(GLint target, GLint level) const;
 
   bool HasImages() const {
     return has_images_;
@@ -263,7 +263,7 @@ class GPU_EXPORT Texture {
     GLint border;
     GLenum format;
     GLenum type;
-    scoped_refptr<gfx::GLImage> image;
+    scoped_refptr<gl::GLImage> image;
     ImageState image_state;
     uint32 estimated_size;
   };
@@ -809,7 +809,7 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
   void SetLevelImage(TextureRef* ref,
                      GLenum target,
                      GLint level,
-                     gfx::GLImage* image,
+                     gl::GLImage* image,
                      Texture::ImageState state);
 
   size_t GetSignatureSize() const;
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 516f478..dc01e7a 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -1390,7 +1390,7 @@ TEST_F(TextureTest, GetLevelImage) {
   Texture* texture = texture_ref_->texture();
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Set image.
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get(),
                           Texture::BOUND);
   EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
@@ -1737,7 +1737,7 @@ TEST_P(ProduceConsumeTextureTest, ProduceConsumeTextureWithImage) {
   manager_->SetTarget(texture_ref_.get(), target);
   Texture* texture = texture_ref_->texture();
   EXPECT_EQ(static_cast<GLenum>(target), texture->target());
-  scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image(new gl::GLImageStub);
   manager_->SetLevelInfo(texture_ref_.get(), target, 0, GL_RGBA, 0, 0, 1, 0,
                          GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   manager_->SetLevelImage(texture_ref_.get(), target, 0, image.get(),
@@ -2060,14 +2060,14 @@ TEST_F(SharedTextureTest, Images) {
   EXPECT_FALSE(ref2->texture()->HasImages());
   EXPECT_FALSE(texture_manager1_->HaveImages());
   EXPECT_FALSE(texture_manager2_->HaveImages());
-  scoped_refptr<gfx::GLImage> image1(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image1(new gl::GLImageStub);
   texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image1.get(),
                                    Texture::BOUND);
   EXPECT_TRUE(ref1->texture()->HasImages());
   EXPECT_TRUE(ref2->texture()->HasImages());
   EXPECT_TRUE(texture_manager1_->HaveImages());
   EXPECT_TRUE(texture_manager2_->HaveImages());
-  scoped_refptr<gfx::GLImage> image2(new gfx::GLImageStub);
+  scoped_refptr<gl::GLImage> image2(new gl::GLImageStub);
   texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image2.get(),
                                    Texture::BOUND);
   EXPECT_TRUE(ref1->texture()->HasImages());
diff --git a/tools/valgrind/drmemory/suppressions_full.txt b/tools/valgrind/drmemory/suppressions_full.txt
index f641f01..55338be 100644
--- a/tools/valgrind/drmemory/suppressions_full.txt
+++ b/tools/valgrind/drmemory/suppressions_full.txt
@@ -1847,7 +1847,7 @@ system call NtDuplicateObject
 KERNELBASE.dll!DuplicateHandle
 KERNEL32.dll!DuplicateHandle
 base.dll!base::SharedMemory::ShareToProcessCommon
-gl_wrapper.dll!gfx::GLImageSharedMemory::Initialize
+gl_wrapper.dll!gl::GLImageSharedMemory::Initialize
 content.dll!content::GpuChannel::CreateImageForGpuMemoryBuffer
 content.dll!content::GpuCommandBufferStub::OnCreateImage
 
diff --git a/ui/gl/gl_image.h b/ui/gl/gl_image.h
index aba2651..c96d3d3 100644
--- a/ui/gl/gl_image.h
+++ b/ui/gl/gl_image.h
@@ -22,7 +22,7 @@ class ProcessMemoryDump;
 }
 }
 
-namespace gfx {
+namespace gl {
 
 // Encapsulates an image that can be bound and/or copied to a texture, hiding
 // platform specific management.
@@ -34,7 +34,7 @@ class GL_EXPORT GLImage : public base::RefCounted<GLImage> {
   virtual void Destroy(bool have_context) = 0;
 
   // Get the size of the image.
-  virtual Size GetSize() = 0;
+  virtual gfx::Size GetSize() = 0;
 
   // Get the internal format of the image.
   virtual unsigned GetInternalFormat() = 0;
@@ -55,15 +55,15 @@ class GL_EXPORT GLImage : public base::RefCounted<GLImage> {
   // Returns true on success. It is valid for an implementation to always
   // return false.
   virtual bool CopyTexSubImage(unsigned target,
-                               const Point& offset,
-                               const Rect& rect) = 0;
+                               const gfx::Point& offset,
+                               const gfx::Rect& rect) = 0;
 
   // Schedule image as an overlay plane to be shown at swap time for |widget|.
-  virtual bool ScheduleOverlayPlane(AcceleratedWidget widget,
+  virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                     int z_order,
-                                    OverlayTransform transform,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect) = 0;
+                                    gfx::OverlayTransform transform,
+                                    const gfx::Rect& bounds_rect,
+                                    const gfx::RectF& crop_rect) = 0;
 
   // Dumps information about the memory backing the GLImage to a dump named
   // |dump_name|.
@@ -80,6 +80,6 @@ class GL_EXPORT GLImage : public base::RefCounted<GLImage> {
   DISALLOW_COPY_AND_ASSIGN(GLImage);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_H_
diff --git a/ui/gl/gl_image_egl.cc b/ui/gl/gl_image_egl.cc
index 6f72c4f..91800e2 100644
--- a/ui/gl/gl_image_egl.cc
+++ b/ui/gl/gl_image_egl.cc
@@ -7,9 +7,9 @@
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_surface_egl.h"
 
-namespace gfx {
+namespace gl {
 
-GLImageEGL::GLImageEGL(const Size& size)
+GLImageEGL::GLImageEGL(const gfx::Size& size)
     : egl_image_(EGL_NO_IMAGE_KHR), size_(size) {}
 
 GLImageEGL::~GLImageEGL() {
@@ -22,7 +22,7 @@ bool GLImageEGL::Initialize(EGLenum target,
                             const EGLint* attrs) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(EGL_NO_IMAGE_KHR, egl_image_);
-  egl_image_ = eglCreateImageKHR(GLSurfaceEGL::GetHardwareDisplay(),
+  egl_image_ = eglCreateImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(),
                                  EGL_NO_CONTEXT,
                                  target,
                                  buffer,
@@ -39,7 +39,7 @@ void GLImageEGL::Destroy(bool have_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (egl_image_ != EGL_NO_IMAGE_KHR) {
     EGLBoolean result =
-        eglDestroyImageKHR(GLSurfaceEGL::GetHardwareDisplay(), egl_image_);
+        eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), egl_image_);
     if (result == EGL_FALSE) {
       DLOG(ERROR) << "Error destroying EGLImage: "
                   << ui::GetLastEGLErrorString();
@@ -48,7 +48,7 @@ void GLImageEGL::Destroy(bool have_context) {
   }
 }
 
-Size GLImageEGL::GetSize() {
+gfx::Size GLImageEGL::GetSize() {
   return size_;
 }
 
@@ -67,17 +67,17 @@ bool GLImageEGL::CopyTexImage(unsigned target) {
 }
 
 bool GLImageEGL::CopyTexSubImage(unsigned target,
-                                 const Point& offset,
-                                 const Rect& rect) {
+                                 const gfx::Point& offset,
+                                 const gfx::Rect& rect) {
   return false;
 }
 
-bool GLImageEGL::ScheduleOverlayPlane(AcceleratedWidget widget,
+bool GLImageEGL::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                       int z_order,
-                                      OverlayTransform transform,
-                                      const Rect& bounds_rect,
-                                      const RectF& crop_rect) {
+                                      gfx::OverlayTransform transform,
+                                      const gfx::Rect& bounds_rect,
+                                      const gfx::RectF& crop_rect) {
   return false;
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_egl.h b/ui/gl/gl_image_egl.h
index 4110fd0d..bb68e10 100644
--- a/ui/gl/gl_image_egl.h
+++ b/ui/gl/gl_image_egl.h
@@ -9,41 +9,41 @@
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
 
-namespace gfx {
+namespace gl {
 
 class GL_EXPORT GLImageEGL : public GLImage {
  public:
-  explicit GLImageEGL(const Size& size);
+  explicit GLImageEGL(const gfx::Size& size);
 
   bool Initialize(EGLenum target, EGLClientBuffer buffer, const EGLint* attrs);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
 
  protected:
   ~GLImageEGL() override;
 
   EGLImageKHR egl_image_;
-  const Size size_;
+  const gfx::Size size_;
   base::ThreadChecker thread_checker_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLImageEGL);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_EGL_H_
diff --git a/ui/gl/gl_image_glx.cc b/ui/gl/gl_image_glx.cc
index f2eddf9..2736e92 100644
--- a/ui/gl/gl_image_glx.cc
+++ b/ui/gl/gl_image_glx.cc
@@ -12,7 +12,7 @@ extern "C" {
 #include "ui/gl/gl_image_glx.h"
 #include "ui/gl/gl_surface_glx.h"
 
-namespace gfx {
+namespace gl {
 namespace {
 
 bool ValidFormat(unsigned internalformat) {
@@ -61,7 +61,7 @@ unsigned PixmapDepth(unsigned internalformat) {
   }
 }
 
-bool ActualPixmapGeometry(XID pixmap, Size* size, unsigned* depth) {
+bool ActualPixmapGeometry(XID pixmap, gfx::Size* size, unsigned* depth) {
   XID root_return;
   int x_return;
   int y_return;
@@ -69,13 +69,13 @@ bool ActualPixmapGeometry(XID pixmap, Size* size, unsigned* depth) {
   unsigned height_return;
   unsigned border_width_return;
   unsigned depth_return;
-  if (!XGetGeometry(GetXDisplay(), pixmap, &root_return, &x_return, &y_return,
-                    &width_return, &height_return, &border_width_return,
-                    &depth_return))
+  if (!XGetGeometry(gfx::GetXDisplay(), pixmap, &root_return, &x_return,
+                    &y_return, &width_return, &height_return,
+                    &border_width_return, &depth_return))
     return false;
 
   if (size)
-    *size = Size(width_return, height_return);
+    *size = gfx::Size(width_return, height_return);
   if (depth)
     *depth = depth_return;
   return true;
@@ -89,17 +89,17 @@ unsigned ActualPixmapDepth(XID pixmap) {
   return depth;
 }
 
-Size ActualPixmapSize(XID pixmap) {
-  Size size;
+gfx::Size ActualPixmapSize(XID pixmap) {
+  gfx::Size size;
   if (!ActualPixmapGeometry(pixmap, &size, NULL))
-    return Size();
+    return gfx::Size();
 
   return size;
 }
 
 }  // namespace
 
-GLImageGLX::GLImageGLX(const Size& size, unsigned internalformat)
+GLImageGLX::GLImageGLX(const gfx::Size& size, unsigned internalformat)
     : glx_pixmap_(0), size_(size), internalformat_(internalformat) {}
 
 GLImageGLX::~GLImageGLX() {
@@ -107,7 +107,7 @@ GLImageGLX::~GLImageGLX() {
 }
 
 bool GLImageGLX::Initialize(XID pixmap) {
-  if (!GLSurfaceGLX::IsTextureFromPixmapSupported()) {
+  if (!gfx::GLSurfaceGLX::IsTextureFromPixmapSupported()) {
     DVLOG(0) << "GLX_EXT_texture_from_pixmap not supported.";
     return false;
   }
@@ -126,8 +126,8 @@ bool GLImageGLX::Initialize(XID pixmap) {
       BindToTextureFormat(internalformat_), GL_TRUE,
       0};
   int num_elements = 0;
-  XScopedPtr<GLXFBConfig> config(
-      glXChooseFBConfig(GetXDisplay(), DefaultScreen(GetXDisplay()),
+  gfx::XScopedPtr<GLXFBConfig> config(
+      glXChooseFBConfig(gfx::GetXDisplay(), DefaultScreen(gfx::GetXDisplay()),
                         config_attribs, &num_elements));
   if (!config.get()) {
     DVLOG(0) << "glXChooseFBConfig failed.";
@@ -141,8 +141,8 @@ bool GLImageGLX::Initialize(XID pixmap) {
   int pixmap_attribs[] = {GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
                           GLX_TEXTURE_FORMAT_EXT,
                           TextureFormat(internalformat_), 0};
-  glx_pixmap_ =
-      glXCreatePixmap(GetXDisplay(), *config.get(), pixmap, pixmap_attribs);
+  glx_pixmap_ = glXCreatePixmap(gfx::GetXDisplay(), *config.get(), pixmap,
+                                pixmap_attribs);
   if (!glx_pixmap_) {
     DVLOG(0) << "glXCreatePixmap failed.";
     return false;
@@ -153,12 +153,12 @@ bool GLImageGLX::Initialize(XID pixmap) {
 
 void GLImageGLX::Destroy(bool have_context) {
   if (glx_pixmap_) {
-    glXDestroyGLXPixmap(GetXDisplay(), glx_pixmap_);
+    glXDestroyGLXPixmap(gfx::GetXDisplay(), glx_pixmap_);
     glx_pixmap_ = 0;
   }
 }
 
-Size GLImageGLX::GetSize() {
+gfx::Size GLImageGLX::GetSize() {
   return size_;
 }
 
@@ -172,7 +172,7 @@ bool GLImageGLX::BindTexImage(unsigned target) {
   if (target != GL_TEXTURE_2D)
     return false;
 
-  glXBindTexImageEXT(GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT, 0);
+  glXBindTexImageEXT(gfx::GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT, 0);
   return true;
 }
 
@@ -180,7 +180,7 @@ void GLImageGLX::ReleaseTexImage(unsigned target) {
   DCHECK_NE(0u, glx_pixmap_);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), target);
 
-  glXReleaseTexImageEXT(GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT);
+  glXReleaseTexImageEXT(gfx::GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT);
 }
 
 bool GLImageGLX::CopyTexImage(unsigned target) {
@@ -188,16 +188,16 @@ bool GLImageGLX::CopyTexImage(unsigned target) {
 }
 
 bool GLImageGLX::CopyTexSubImage(unsigned target,
-                                 const Point& offset,
-                                 const Rect& rect) {
+                                 const gfx::Point& offset,
+                                 const gfx::Rect& rect) {
   return false;
 }
 
-bool GLImageGLX::ScheduleOverlayPlane(AcceleratedWidget widget,
+bool GLImageGLX::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                       int z_order,
-                                      OverlayTransform transform,
-                                      const Rect& bounds_rect,
-                                      const RectF& crop_rect) {
+                                      gfx::OverlayTransform transform,
+                                      const gfx::Rect& bounds_rect,
+                                      const gfx::RectF& crop_rect) {
   return false;
 }
 
@@ -207,4 +207,4 @@ void GLImageGLX::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
   // TODO(ericrk): Implement GLImage OnMemoryDump. crbug.com/514914
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_glx.h b/ui/gl/gl_image_glx.h
index e22512e..fa577f0 100644
--- a/ui/gl/gl_image_glx.h
+++ b/ui/gl/gl_image_glx.h
@@ -10,29 +10,29 @@
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_image.h"
 
-namespace gfx {
+namespace gl {
 
 class GL_EXPORT GLImageGLX : public GLImage {
  public:
-  GLImageGLX(const Size& size, unsigned internalformat);
+  GLImageGLX(const gfx::Size& size, unsigned internalformat);
 
   bool Initialize(XID pixmap);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override;
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                     uint64_t process_tracing_id,
                     const std::string& dump_name) override;
@@ -42,12 +42,12 @@ class GL_EXPORT GLImageGLX : public GLImage {
 
  private:
   XID glx_pixmap_;
-  const Size size_;
+  const gfx::Size size_;
   unsigned internalformat_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageGLX);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_GLX_H_
diff --git a/ui/gl/gl_image_io_surface.h b/ui/gl/gl_image_io_surface.h
index 16e35b2..186f5a9 100644
--- a/ui/gl/gl_image_io_surface.h
+++ b/ui/gl/gl_image_io_surface.h
@@ -19,31 +19,31 @@
 typedef void* CALayer;
 #endif
 
-namespace gfx {
+namespace gl {
 
 class GL_EXPORT GLImageIOSurface : public GLImage {
  public:
-  GLImageIOSurface(const Size& size, unsigned internalformat);
+  GLImageIOSurface(const gfx::Size& size, unsigned internalformat);
 
   bool Initialize(IOSurfaceRef io_surface,
-                  GenericSharedMemoryId io_surface_id,
-                  BufferFormat format);
+                  gfx::GenericSharedMemoryId io_surface_id,
+                  gfx::BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                     uint64_t process_tracing_id,
                     const std::string& dump_name) override;
@@ -51,22 +51,22 @@ class GL_EXPORT GLImageIOSurface : public GLImage {
   gfx::GenericSharedMemoryId io_surface_id() const { return io_surface_id_; }
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface();
 
-  static void SetLayerForWidget(AcceleratedWidget widget, CALayer* layer);
+  static void SetLayerForWidget(gfx::AcceleratedWidget widget, CALayer* layer);
 
  protected:
   ~GLImageIOSurface() override;
 
  private:
-  const Size size_;
+  const gfx::Size size_;
   const unsigned internalformat_;
-  BufferFormat format_;
+  gfx::BufferFormat format_;
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface_;
-  GenericSharedMemoryId io_surface_id_;
+  gfx::GenericSharedMemoryId io_surface_id_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageIOSurface);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_IO_SURFACE_H_
diff --git a/ui/gl/gl_image_io_surface.mm b/ui/gl/gl_image_io_surface.mm
index fe34240..5e006dc 100644
--- a/ui/gl/gl_image_io_surface.mm
+++ b/ui/gl/gl_image_io_surface.mm
@@ -18,10 +18,12 @@
 #include <OpenGL/CGLIOSurface.h>
 #include <Quartz/Quartz.h>
 
-namespace gfx {
+using gfx::BufferFormat;
+
+namespace gl {
 namespace {
 
-using WidgetToLayerMap = std::map<AcceleratedWidget, CALayer*>;
+using WidgetToLayerMap = std::map<gfx::AcceleratedWidget, CALayer*>;
 base::LazyInstance<WidgetToLayerMap> g_widget_to_layer_map;
 
 bool ValidInternalFormat(unsigned internalformat) {
@@ -145,7 +147,8 @@ GLenum DataType(BufferFormat format) {
 
 }  // namespace
 
-GLImageIOSurface::GLImageIOSurface(const Size& size, unsigned internalformat)
+GLImageIOSurface::GLImageIOSurface(const gfx::Size& size,
+                                   unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       format_(BufferFormat::RGBA_8888) {}
@@ -156,7 +159,7 @@ GLImageIOSurface::~GLImageIOSurface() {
 }
 
 bool GLImageIOSurface::Initialize(IOSurfaceRef io_surface,
-                                  GenericSharedMemoryId io_surface_id,
+                                  gfx::GenericSharedMemoryId io_surface_id,
                                   BufferFormat format) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!io_surface_);
@@ -182,7 +185,7 @@ void GLImageIOSurface::Destroy(bool have_context) {
   io_surface_.reset();
 }
 
-Size GLImageIOSurface::GetSize() {
+gfx::Size GLImageIOSurface::GetSize() {
   return size_;
 }
 
@@ -198,7 +201,7 @@ bool GLImageIOSurface::BindTexImage(unsigned target) {
   }
 
   CGLContextObj cgl_context =
-      static_cast<CGLContextObj>(GLContext::GetCurrent()->GetHandle());
+      static_cast<CGLContextObj>(gfx::GLContext::GetCurrent()->GetHandle());
 
   DCHECK(io_surface_);
   CGLError cgl_error =
@@ -218,16 +221,16 @@ bool GLImageIOSurface::CopyTexImage(unsigned target) {
 }
 
 bool GLImageIOSurface::CopyTexSubImage(unsigned target,
-                                       const Point& offset,
-                                       const Rect& rect) {
+                                       const gfx::Point& offset,
+                                       const gfx::Rect& rect) {
   return false;
 }
 
-bool GLImageIOSurface::ScheduleOverlayPlane(AcceleratedWidget widget,
+bool GLImageIOSurface::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                             int z_order,
-                                            OverlayTransform transform,
-                                            const Rect& bounds_rect,
-                                            const RectF& crop_rect) {
+                                            gfx::OverlayTransform transform,
+                                            const gfx::Rect& bounds_rect,
+                                            const gfx::RectF& crop_rect) {
   NOTREACHED();
   return false;
 }
@@ -256,7 +259,7 @@ base::ScopedCFTypeRef<IOSurfaceRef> GLImageIOSurface::io_surface() {
 }
 
 // static
-void GLImageIOSurface::SetLayerForWidget(AcceleratedWidget widget,
+void GLImageIOSurface::SetLayerForWidget(gfx::AcceleratedWidget widget,
                                          CALayer* layer) {
   if (layer)
     g_widget_to_layer_map.Pointer()->insert(std::make_pair(widget, layer));
diff --git a/ui/gl/gl_image_memory.cc b/ui/gl/gl_image_memory.cc
index 2ced365..2f8a45d 100644
--- a/ui/gl/gl_image_memory.cc
+++ b/ui/gl/gl_image_memory.cc
@@ -11,7 +11,9 @@
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_version_info.h"
 
-namespace gfx {
+using gfx::BufferFormat;
+
+namespace gl {
 namespace {
 
 bool ValidInternalFormat(unsigned internalformat) {
@@ -164,7 +166,7 @@ GLenum DataType(BufferFormat format) {
 }
 
 template <typename F>
-scoped_ptr<uint8_t[]> GLES2RGBData(const Size& size,
+scoped_ptr<uint8_t[]> GLES2RGBData(const gfx::Size& size,
                                    BufferFormat format,
                                    const uint8_t* data,
                                    F const& data_to_rgb,
@@ -192,7 +194,7 @@ scoped_ptr<uint8_t[]> GLES2RGBData(const Size& size,
   return gles2_rgb_data.Pass();
 }
 
-scoped_ptr<uint8_t[]> GLES2Data(const Size& size,
+scoped_ptr<uint8_t[]> GLES2Data(const gfx::Size& size,
                                 BufferFormat format,
                                 const uint8_t* data,
                                 GLenum* data_format,
@@ -234,7 +236,7 @@ scoped_ptr<uint8_t[]> GLES2Data(const Size& size,
 
 }  // namespace
 
-GLImageMemory::GLImageMemory(const Size& size, unsigned internalformat)
+GLImageMemory::GLImageMemory(const gfx::Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(nullptr),
@@ -269,7 +271,7 @@ void GLImageMemory::Destroy(bool have_context) {
   memory_ = nullptr;
 }
 
-Size GLImageMemory::GetSize() {
+gfx::Size GLImageMemory::GetSize() {
   return size_;
 }
 
@@ -299,7 +301,7 @@ bool GLImageMemory::CopyTexImage(unsigned target) {
     GLenum data_format = DataFormat(format_);
     GLenum data_type = DataType(format_);
 
-    if (GLContext::GetCurrent()->GetVersionInfo()->is_es)
+    if (gfx::GLContext::GetCurrent()->GetVersionInfo()->is_es)
       gles2_data = GLES2Data(size_, format_, memory_, &data_format, &data_type);
 
     glTexImage2D(target, 0, TextureFormat(format_), size_.width(),
@@ -311,8 +313,8 @@ bool GLImageMemory::CopyTexImage(unsigned target) {
 }
 
 bool GLImageMemory::CopyTexSubImage(unsigned target,
-                                    const Point& offset,
-                                    const Rect& rect) {
+                                    const gfx::Point& offset,
+                                    const gfx::Rect& rect) {
   TRACE_EVENT2("gpu", "GLImageMemory::CopyTexSubImage", "width", rect.width(),
                "height", rect.height());
 
@@ -341,7 +343,7 @@ bool GLImageMemory::CopyTexSubImage(unsigned target,
     GLenum data_type = DataType(format_);
     scoped_ptr<uint8_t[]> gles2_data;
 
-    if (GLContext::GetCurrent()->GetVersionInfo()->is_es) {
+    if (gfx::GLContext::GetCurrent()->GetVersionInfo()->is_es) {
       gles2_data =
           GLES2Data(rect.size(), format_, data, &data_format, &data_type);
     }
@@ -354,11 +356,11 @@ bool GLImageMemory::CopyTexSubImage(unsigned target,
   return true;
 }
 
-bool GLImageMemory::ScheduleOverlayPlane(AcceleratedWidget widget,
+bool GLImageMemory::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                          int z_order,
-                                         OverlayTransform transform,
-                                         const Rect& bounds_rect,
-                                         const RectF& crop_rect) {
+                                         gfx::OverlayTransform transform,
+                                         const gfx::Rect& bounds_rect,
+                                         const gfx::RectF& crop_rect) {
   return false;
 }
 
@@ -368,4 +370,4 @@ unsigned GLImageMemory::GetInternalFormatForTesting(BufferFormat format) {
   return TextureFormat(format);
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_memory.h b/ui/gl/gl_image_memory.h
index 3ee67b2..3ce0440 100644
--- a/ui/gl/gl_image_memory.h
+++ b/ui/gl/gl_image_memory.h
@@ -10,46 +10,46 @@
 #include "base/numerics/safe_math.h"
 #include "ui/gfx/buffer_types.h"
 
-namespace gfx {
+namespace gl {
 
 class GL_EXPORT GLImageMemory : public GLImage {
  public:
-  GLImageMemory(const Size& size, unsigned internalformat);
+  GLImageMemory(const gfx::Size& size, unsigned internalformat);
 
-  bool Initialize(const unsigned char* memory, BufferFormat format);
+  bool Initialize(const unsigned char* memory, gfx::BufferFormat format);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
 
-  static unsigned GetInternalFormatForTesting(BufferFormat format);
+  static unsigned GetInternalFormatForTesting(gfx::BufferFormat format);
 
  protected:
   ~GLImageMemory() override;
 
-  BufferFormat format() const { return format_; }
+  gfx::BufferFormat format() const { return format_; }
 
  private:
-  const Size size_;
+  const gfx::Size size_;
   const unsigned internalformat_;
   const unsigned char* memory_;
-  BufferFormat format_;
+  gfx::BufferFormat format_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageMemory);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_MEMORY_H_
diff --git a/ui/gl/gl_image_ozone_native_pixmap.cc b/ui/gl/gl_image_ozone_native_pixmap.cc
index ab44d19..8184261 100644
--- a/ui/gl/gl_image_ozone_native_pixmap.cc
+++ b/ui/gl/gl_image_ozone_native_pixmap.cc
@@ -81,7 +81,7 @@ EGLint FourCC(BufferFormat format) {
 
 GLImageOzoneNativePixmap::GLImageOzoneNativePixmap(const Size& size,
                                                    unsigned internalformat)
-    : GLImageEGL(size), internalformat_(internalformat) {}
+    : gl::GLImageEGL(size), internalformat_(internalformat) {}
 
 GLImageOzoneNativePixmap::~GLImageOzoneNativePixmap() {
 }
@@ -91,8 +91,8 @@ bool GLImageOzoneNativePixmap::Initialize(ui::NativePixmap* pixmap,
   DCHECK(!pixmap_);
   if (pixmap->GetEGLClientBuffer()) {
     EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
-    if (!GLImageEGL::Initialize(EGL_NATIVE_PIXMAP_KHR,
-                                pixmap->GetEGLClientBuffer(), attrs)) {
+    if (!gl::GLImageEGL::Initialize(EGL_NATIVE_PIXMAP_KHR,
+                                    pixmap->GetEGLClientBuffer(), attrs)) {
       return false;
     }
   } else if (pixmap->GetDmaBufFd() >= 0) {
@@ -121,8 +121,9 @@ bool GLImageOzoneNativePixmap::Initialize(ui::NativePixmap* pixmap,
                       EGL_DMA_BUF_PLANE0_PITCH_EXT,
                       pixmap->GetDmaBufPitch(),
                       EGL_NONE};
-    if (!GLImageEGL::Initialize(EGL_LINUX_DMA_BUF_EXT,
-                                static_cast<EGLClientBuffer>(nullptr), attrs)) {
+    if (!gl::GLImageEGL::Initialize(EGL_LINUX_DMA_BUF_EXT,
+                                    static_cast<EGLClientBuffer>(nullptr),
+                                    attrs)) {
       return false;
     }
   }
@@ -136,7 +137,7 @@ unsigned GLImageOzoneNativePixmap::GetInternalFormat() {
 }
 
 void GLImageOzoneNativePixmap::Destroy(bool have_context) {
-  GLImageEGL::Destroy(have_context);
+  gl::GLImageEGL::Destroy(have_context);
 }
 
 bool GLImageOzoneNativePixmap::ScheduleOverlayPlane(AcceleratedWidget widget,
diff --git a/ui/gl/gl_image_ozone_native_pixmap.h b/ui/gl/gl_image_ozone_native_pixmap.h
index 6505299..f76e98b 100644
--- a/ui/gl/gl_image_ozone_native_pixmap.h
+++ b/ui/gl/gl_image_ozone_native_pixmap.h
@@ -11,7 +11,7 @@
 
 namespace gfx {
 
-class GL_EXPORT GLImageOzoneNativePixmap : public GLImageEGL {
+class GL_EXPORT GLImageOzoneNativePixmap : public gl::GLImageEGL {
  public:
   GLImageOzoneNativePixmap(const Size& size, unsigned internalformat);
 
diff --git a/ui/gl/gl_image_ref_counted_memory.h b/ui/gl/gl_image_ref_counted_memory.h
index f68acc5..e4390d9 100644
--- a/ui/gl/gl_image_ref_counted_memory.h
+++ b/ui/gl/gl_image_ref_counted_memory.h
@@ -14,7 +14,7 @@ class RefCountedMemory;
 
 namespace gfx {
 
-class GL_EXPORT GLImageRefCountedMemory : public GLImageMemory {
+class GL_EXPORT GLImageRefCountedMemory : public gl::GLImageMemory {
  public:
   GLImageRefCountedMemory(const Size& size, unsigned internalformat);
 
diff --git a/ui/gl/gl_image_ref_counted_memory_unittest.cc b/ui/gl/gl_image_ref_counted_memory_unittest.cc
index be25e63..1750a45 100644
--- a/ui/gl/gl_image_ref_counted_memory_unittest.cc
+++ b/ui/gl/gl_image_ref_counted_memory_unittest.cc
@@ -15,8 +15,9 @@ namespace {
 template <BufferFormat format>
 class GLImageRefCountedMemoryTestDelegate {
  public:
-  scoped_refptr<GLImage> CreateSolidColorImage(const Size& size,
-                                               const uint8_t color[4]) const {
+  scoped_refptr<gl::GLImage> CreateSolidColorImage(
+      const Size& size,
+      const uint8_t color[4]) const {
     DCHECK_EQ(NumberOfPlanesForBufferFormat(format), 1u);
     std::vector<uint8_t> data(BufferSizeForBufferFormat(size, format));
     scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
@@ -25,7 +26,7 @@ class GLImageRefCountedMemoryTestDelegate {
         static_cast<int>(RowSizeForBufferFormat(size.width(), format, 0)),
         format, color, &bytes->data().front());
     scoped_refptr<GLImageRefCountedMemory> image(new GLImageRefCountedMemory(
-        size, GLImageMemory::GetInternalFormatForTesting(format)));
+        size, gl::GLImageMemory::GetInternalFormatForTesting(format)));
     bool rv = image->Initialize(bytes.get(), format);
     EXPECT_TRUE(rv);
     return image;
diff --git a/ui/gl/gl_image_shared_memory.cc b/ui/gl/gl_image_shared_memory.cc
index aa86600..6ea5553 100644
--- a/ui/gl/gl_image_shared_memory.cc
+++ b/ui/gl/gl_image_shared_memory.cc
@@ -14,9 +14,9 @@
 #include "base/trace_event/process_memory_dump.h"
 #include "ui/gfx/buffer_format_util.h"
 
-namespace gfx {
+namespace gl {
 
-GLImageSharedMemory::GLImageSharedMemory(const Size& size,
+GLImageSharedMemory::GLImageSharedMemory(const gfx::Size& size,
                                          unsigned internalformat)
     : GLImageMemory(size, internalformat) {}
 
@@ -24,10 +24,11 @@ GLImageSharedMemory::~GLImageSharedMemory() {
   DCHECK(!shared_memory_);
 }
 
-bool GLImageSharedMemory::Initialize(const base::SharedMemoryHandle& handle,
-                                     GenericSharedMemoryId shared_memory_id,
-                                     BufferFormat format,
-                                     size_t offset) {
+bool GLImageSharedMemory::Initialize(
+    const base::SharedMemoryHandle& handle,
+    gfx::GenericSharedMemoryId shared_memory_id,
+    gfx::BufferFormat format,
+    size_t offset) {
   size_t size_in_bytes;
   if (!BufferSizeForBufferFormatChecked(GetSize(), format, &size_in_bytes))
     return false;
@@ -104,4 +105,4 @@ void GLImageSharedMemory::OnMemoryDump(
   pmd->AddOwnershipEdge(dump->guid(), guid);
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_shared_memory.h b/ui/gl/gl_image_shared_memory.h
index 1d865a4..e3425d2 100644
--- a/ui/gl/gl_image_shared_memory.h
+++ b/ui/gl/gl_image_shared_memory.h
@@ -14,15 +14,15 @@ namespace base {
 class SharedMemory;
 }
 
-namespace gfx {
+namespace gl {
 
 class GL_EXPORT GLImageSharedMemory : public GLImageMemory {
  public:
-  GLImageSharedMemory(const Size& size, unsigned internalformat);
+  GLImageSharedMemory(const gfx::Size& size, unsigned internalformat);
 
   bool Initialize(const base::SharedMemoryHandle& handle,
-                  GenericSharedMemoryId shared_memory_id,
-                  BufferFormat format,
+                  gfx::GenericSharedMemoryId shared_memory_id,
+                  gfx::BufferFormat format,
                   size_t offset);
 
   // Overridden from GLImage:
@@ -36,11 +36,11 @@ class GL_EXPORT GLImageSharedMemory : public GLImageMemory {
 
  private:
   scoped_ptr<base::SharedMemory> shared_memory_;
-  GenericSharedMemoryId shared_memory_id_;
+  gfx::GenericSharedMemoryId shared_memory_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSharedMemory);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_SHARED_MEMORY_H_
diff --git a/ui/gl/gl_image_shared_memory_unittest.cc b/ui/gl/gl_image_shared_memory_unittest.cc
index 48dfce6..c7b85db 100644
--- a/ui/gl/gl_image_shared_memory_unittest.cc
+++ b/ui/gl/gl_image_shared_memory_unittest.cc
@@ -14,8 +14,9 @@ namespace {
 template <BufferFormat format>
 class GLImageSharedMemoryTestDelegate {
  public:
-  scoped_refptr<GLImage> CreateSolidColorImage(const Size& size,
-                                               const uint8_t color[4]) const {
+  scoped_refptr<gl::GLImage> CreateSolidColorImage(
+      const Size& size,
+      const uint8_t color[4]) const {
     DCHECK_EQ(NumberOfPlanesForBufferFormat(format), 1u);
     base::SharedMemory shared_memory;
     bool rv = shared_memory.CreateAndMapAnonymous(
@@ -25,8 +26,8 @@ class GLImageSharedMemoryTestDelegate {
         size.width(), size.height(),
         static_cast<int>(RowSizeForBufferFormat(size.width(), format, 0)),
         format, color, reinterpret_cast<uint8_t*>(shared_memory.memory()));
-    scoped_refptr<GLImageSharedMemory> image(new GLImageSharedMemory(
-        size, GLImageMemory::GetInternalFormatForTesting(format)));
+    scoped_refptr<gl::GLImageSharedMemory> image(new gl::GLImageSharedMemory(
+        size, gl::GLImageMemory::GetInternalFormatForTesting(format)));
     rv = image->Initialize(
         base::SharedMemory::DuplicateHandle(shared_memory.handle()),
         GenericSharedMemoryId(0), format, 0);
@@ -51,7 +52,7 @@ INSTANTIATE_TYPED_TEST_CASE_P(GLImageSharedMemory,
 
 class GLImageSharedMemoryPoolTestDelegate {
  public:
-  scoped_refptr<GLImage> CreateSolidColorImage(const Size& size,
+  scoped_refptr<gl::GLImage> CreateSolidColorImage(const Size& size,
                                                const uint8_t color[4]) const {
     // Create a shared memory segment that is 2 pages larger than image.
     size_t pool_size =
@@ -70,8 +71,8 @@ class GLImageSharedMemoryPoolTestDelegate {
             RowSizeForBufferFormat(size.width(), BufferFormat::RGBA_8888, 0)),
         BufferFormat::RGBA_8888, color,
         reinterpret_cast<uint8_t*>(shared_memory.memory()) + buffer_offset);
-    scoped_refptr<GLImageSharedMemory> image(
-        new GLImageSharedMemory(size, GL_RGBA));
+    scoped_refptr<gl::GLImageSharedMemory> image(
+        new gl::GLImageSharedMemory(size, GL_RGBA));
     rv = image->Initialize(
         base::SharedMemory::DuplicateHandle(shared_memory.handle()),
         GenericSharedMemoryId(0), BufferFormat::RGBA_8888, buffer_offset);
diff --git a/ui/gl/gl_image_stub.cc b/ui/gl/gl_image_stub.cc
index 803a05f..5bfd62b 100644
--- a/ui/gl/gl_image_stub.cc
+++ b/ui/gl/gl_image_stub.cc
@@ -6,14 +6,14 @@
 
 #include <GL/gl.h>
 
-namespace gfx {
+namespace gl {
 
 GLImageStub::GLImageStub() {}
 
 GLImageStub::~GLImageStub() {}
 
-Size GLImageStub::GetSize() {
-  return Size(1, 1);
+gfx::Size GLImageStub::GetSize() {
+  return gfx::Size(1, 1);
 }
 
 unsigned GLImageStub::GetInternalFormat() { return GL_RGBA; }
@@ -25,17 +25,17 @@ bool GLImageStub::CopyTexImage(unsigned target) {
 }
 
 bool GLImageStub::CopyTexSubImage(unsigned target,
-                                  const Point& offset,
-                                  const Rect& rect) {
+                                  const gfx::Point& offset,
+                                  const gfx::Rect& rect) {
   return true;
 }
 
-bool GLImageStub::ScheduleOverlayPlane(AcceleratedWidget widget,
+bool GLImageStub::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                        int z_order,
-                                       OverlayTransform transform,
-                                       const Rect& bounds_rect,
-                                       const RectF& crop_rect) {
+                                       gfx::OverlayTransform transform,
+                                       const gfx::Rect& bounds_rect,
+                                       const gfx::RectF& crop_rect) {
   return false;
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_stub.h b/ui/gl/gl_image_stub.h
index c95fda9..b5f5744 100644
--- a/ui/gl/gl_image_stub.h
+++ b/ui/gl/gl_image_stub.h
@@ -7,7 +7,7 @@
 
 #include "ui/gl/gl_image.h"
 
-namespace gfx {
+namespace gl {
 
 // A GLImage that does nothing for unit tests.
 class GL_EXPORT GLImageStub : public GLImage {
@@ -16,19 +16,19 @@ class GL_EXPORT GLImageStub : public GLImage {
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override {}
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                     uint64_t process_tracing_id,
                     const std::string& dump_name) override {}
@@ -37,6 +37,6 @@ class GL_EXPORT GLImageStub : public GLImage {
   ~GLImageStub() override;
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_STUB_H_
diff --git a/ui/gl/gl_image_surface_texture.cc b/ui/gl/gl_image_surface_texture.cc
index 6ad3667..e47392d 100644
--- a/ui/gl/gl_image_surface_texture.cc
+++ b/ui/gl/gl_image_surface_texture.cc
@@ -7,9 +7,9 @@
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/android/surface_texture.h"
 
-namespace gfx {
+namespace gl {
 
-GLImageSurfaceTexture::GLImageSurfaceTexture(const Size& size)
+GLImageSurfaceTexture::GLImageSurfaceTexture(const gfx::Size& size)
     : size_(size), texture_id_(0) {}
 
 GLImageSurfaceTexture::~GLImageSurfaceTexture() {
@@ -18,7 +18,7 @@ GLImageSurfaceTexture::~GLImageSurfaceTexture() {
   DCHECK_EQ(0, texture_id_);
 }
 
-bool GLImageSurfaceTexture::Initialize(SurfaceTexture* surface_texture) {
+bool GLImageSurfaceTexture::Initialize(gfx::SurfaceTexture* surface_texture) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_texture_.get());
   surface_texture_ = surface_texture;
@@ -31,7 +31,7 @@ void GLImageSurfaceTexture::Destroy(bool have_context) {
   texture_id_ = 0;
 }
 
-Size GLImageSurfaceTexture::GetSize() {
+gfx::Size GLImageSurfaceTexture::GetSize() {
   return size_;
 }
 
@@ -84,16 +84,17 @@ bool GLImageSurfaceTexture::CopyTexImage(unsigned target) {
 }
 
 bool GLImageSurfaceTexture::CopyTexSubImage(unsigned target,
-                                            const Point& offset,
-                                            const Rect& rect) {
+                                            const gfx::Point& offset,
+                                            const gfx::Rect& rect) {
   return false;
 }
 
-bool GLImageSurfaceTexture::ScheduleOverlayPlane(AcceleratedWidget widget,
-                                                 int z_order,
-                                                 OverlayTransform transform,
-                                                 const Rect& bounds_rect,
-                                                 const RectF& crop_rect) {
+bool GLImageSurfaceTexture::ScheduleOverlayPlane(
+    gfx::AcceleratedWidget widget,
+    int z_order,
+    gfx::OverlayTransform transform,
+    const gfx::Rect& bounds_rect,
+    const gfx::RectF& crop_rect) {
   return false;
 }
 
@@ -104,4 +105,4 @@ void GLImageSurfaceTexture::OnMemoryDump(
   // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
 }
 
-}  // namespace gfx
+}  // namespace gl
diff --git a/ui/gl/gl_image_surface_texture.h b/ui/gl/gl_image_surface_texture.h
index f18eaa2..808f85b 100644
--- a/ui/gl/gl_image_surface_texture.h
+++ b/ui/gl/gl_image_surface_texture.h
@@ -12,28 +12,31 @@
 
 namespace gfx {
 class SurfaceTexture;
+}
+
+namespace gl {
 
 class GL_EXPORT GLImageSurfaceTexture : public GLImage {
  public:
-  explicit GLImageSurfaceTexture(const Size& size);
+  explicit GLImageSurfaceTexture(const gfx::Size& size);
 
-  bool Initialize(SurfaceTexture* surface_texture);
+  bool Initialize(gfx::SurfaceTexture* surface_texture);
 
   // Overridden from GLImage:
   void Destroy(bool have_context) override;
-  Size GetSize() override;
+  gfx::Size GetSize() override;
   unsigned GetInternalFormat() override;
   bool BindTexImage(unsigned target) override;
   void ReleaseTexImage(unsigned target) override {}
   bool CopyTexImage(unsigned target) override;
   bool CopyTexSubImage(unsigned target,
-                       const Point& offset,
-                       const Rect& rect) override;
-  bool ScheduleOverlayPlane(AcceleratedWidget widget,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override;
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                             int z_order,
-                            OverlayTransform transform,
-                            const Rect& bounds_rect,
-                            const RectF& crop_rect) override;
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override;
   void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                     uint64_t process_tracing_id,
                     const std::string& dump_name) override;
@@ -42,14 +45,14 @@ class GL_EXPORT GLImageSurfaceTexture : public GLImage {
   ~GLImageSurfaceTexture() override;
 
  private:
-  scoped_refptr<SurfaceTexture> surface_texture_;
-  const Size size_;
+  scoped_refptr<gfx::SurfaceTexture> surface_texture_;
+  const gfx::Size size_;
   GLint texture_id_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSurfaceTexture);
 };
 
-}  // namespace gfx
+}  // namespace gl
 
 #endif  // UI_GL_GL_IMAGE_SURFACE_TEXTURE_H_
diff --git a/ui/gl/gl_surface.cc b/ui/gl/gl_surface.cc
index 92033fd..941b06b 100644
--- a/ui/gl/gl_surface.cc
+++ b/ui/gl/gl_surface.cc
@@ -182,7 +182,7 @@ VSyncProvider* GLSurface::GetVSyncProvider() {
 
 bool GLSurface::ScheduleOverlayPlane(int z_order,
                                      OverlayTransform transform,
-                                     GLImage* image,
+                                     gl::GLImage* image,
                                      const Rect& bounds_rect,
                                      const RectF& crop_rect) {
   NOTIMPLEMENTED();
@@ -320,7 +320,7 @@ VSyncProvider* GLSurfaceAdapter::GetVSyncProvider() {
 
 bool GLSurfaceAdapter::ScheduleOverlayPlane(int z_order,
                                             OverlayTransform transform,
-                                            GLImage* image,
+                                            gl::GLImage* image,
                                             const Rect& bounds_rect,
                                             const RectF& crop_rect) {
   return surface_->ScheduleOverlayPlane(
diff --git a/ui/gl/gl_surface.h b/ui/gl/gl_surface.h
index 5d98253..b928c67 100644
--- a/ui/gl/gl_surface.h
+++ b/ui/gl/gl_surface.h
@@ -19,10 +19,13 @@
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_implementation.h"
 
+namespace gl {
+class GLImage;
+}
+
 namespace gfx {
 
 class GLContext;
-class GLImage;
 class VSyncProvider;
 
 // Encapsulates a surface that can be rendered to with GL, hiding platform
@@ -137,7 +140,7 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
   // |bounds_rect|.
   virtual bool ScheduleOverlayPlane(int z_order,
                                     OverlayTransform transform,
-                                    GLImage* image,
+                                    gl::GLImage* image,
                                     const Rect& bounds_rect,
                                     const RectF& crop_rect);
 
@@ -218,7 +221,7 @@ class GL_EXPORT GLSurfaceAdapter : public GLSurface {
   VSyncProvider* GetVSyncProvider() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
-                            GLImage* image,
+                            gl::GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
   bool IsSurfaceless() const override;
diff --git a/ui/gl/gl_surface_ozone.cc b/ui/gl/gl_surface_ozone.cc
index 377597d..0e3f8b9 100644
--- a/ui/gl/gl_surface_ozone.cc
+++ b/ui/gl/gl_surface_ozone.cc
@@ -27,6 +27,8 @@
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
+using gl::GLImage;
+
 namespace gfx {
 
 namespace {
diff --git a/ui/gl/test/gl_image_test_template.h b/ui/gl/test/gl_image_test_template.h
index 9bee385..fc09d42 100644
--- a/ui/gl/test/gl_image_test_template.h
+++ b/ui/gl/test/gl_image_test_template.h
@@ -58,13 +58,13 @@ TYPED_TEST_P(GLImageTest, CreateAndDestroy) {
 
   // Create a small solid color green image of preferred format. This must
   // succeed in order for a GLImage to be conformant.
-  scoped_refptr<GLImage> small_image =
+  scoped_refptr<gl::GLImage> small_image =
       this->delegate_.CreateSolidColorImage(small_image_size, image_color);
   ASSERT_TRUE(small_image);
 
   // Create a large solid color green image of preferred format. This must
   // succeed in order for a GLImage to be conformant.
-  scoped_refptr<GLImage> large_image =
+  scoped_refptr<gl::GLImage> large_image =
       this->delegate_.CreateSolidColorImage(large_image_size, image_color);
   ASSERT_TRUE(large_image);
 
@@ -100,7 +100,7 @@ TYPED_TEST_P(GLImageCopyTest, CopyTexImage) {
 
   // Create a solid color green image of preferred format. This must succeed
   // in order for a GLImage to be conformant.
-  scoped_refptr<GLImage> image =
+  scoped_refptr<gl::GLImage> image =
       this->delegate_.CreateSolidColorImage(image_size, image_color);
   ASSERT_TRUE(image);
 
diff --git a/ui/ozone/demo/surfaceless_gl_renderer.h b/ui/ozone/demo/surfaceless_gl_renderer.h
index ef90885..b23a618 100644
--- a/ui/ozone/demo/surfaceless_gl_renderer.h
+++ b/ui/ozone/demo/surfaceless_gl_renderer.h
@@ -7,9 +7,9 @@
 
 #include "ui/ozone/demo/gl_renderer.h"
 
-namespace gfx {
+namespace gl {
 class GLImage;
-}  // namespace gfx
+}
 
 namespace ui {
 
@@ -33,7 +33,7 @@ class SurfacelessGlRenderer : public GlRenderer {
     BufferWrapper();
     ~BufferWrapper();
 
-    gfx::GLImage* image() const { return image_.get(); }
+    gl::GLImage* image() const { return image_.get(); }
 
     bool Initialize(gfx::AcceleratedWidget widget, const gfx::Size& size);
     void BindFramebuffer();
@@ -42,7 +42,7 @@ class SurfacelessGlRenderer : public GlRenderer {
     gfx::AcceleratedWidget widget_ = gfx::kNullAcceleratedWidget;
     gfx::Size size_;
 
-    scoped_refptr<gfx::GLImage> image_;
+    scoped_refptr<gl::GLImage> image_;
     unsigned int gl_fb_ = 0;
     unsigned int gl_tex_ = 0;
   };