ui/gl: Move GLImage into gl namespace.

ui/gl/gl_image_memory.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gl/gl_image_memory.h"
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gl/gl_bindings.h"
 #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) {
   switch (internalformat) {
     case GL_ATC_RGB_AMD:
     case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
     case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
     case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
     case GL_ETC1_RGB8_OES:
     case GL_R8:
@@ skipping 132 matching lines @@
     case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 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,
                                    GLenum* data_format,
                                    GLenum* data_type) {
   TRACE_EVENT2("gpu", "GLES2RGBData", "width", size.width(), "height",
                size.height());
 
   // Four-byte row alignment as specified by glPixelStorei with argument
   // GL_UNPACK_ALIGNMENT set to 4.
   size_t gles2_rgb_data_stride = (size.width() * 3 + 3) & ~3;
   scoped_ptr<uint8_t[]> gles2_rgb_data(
       new uint8_t[gles2_rgb_data_stride * size.height()]);
   size_t data_stride = RowSizeForBufferFormat(size.width(), format, 0);
 
   for (int y = 0; y < size.height(); ++y) {
     for (int x = 0; x < size.width(); ++x) {
       data_to_rgb(&data[y * data_stride + x * 4],
                   &gles2_rgb_data[y * gles2_rgb_data_stride + x * 3]);
     }
   }
 
   *data_format = GL_RGB;
   *data_type = GL_UNSIGNED_BYTE;
   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,
                                 GLenum* data_type) {
   switch (format) {
     case BufferFormat::RGBX_8888:
       return GLES2RGBData(size, format,
                           data, [](const uint8_t* src, uint8_t* dst) {
                             dst[0] = src[0];
                             dst[1] = src[1];
@@ skipping 21 matching lines @@
       // No data conversion needed.
       return nullptr;
   }
 
   NOTREACHED();
   return 0;
 }
 
 }  // namespace
 
-GLImageMemory::GLImageMemory(const Size& size, unsigned internalformat)
+GLImageMemory::GLImageMemory(const gfx::Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(nullptr),
       format_(BufferFormat::RGBA_8888) {}
 
 GLImageMemory::~GLImageMemory() {
   DCHECK(!memory_);
 }
 
 bool GLImageMemory::Initialize(const unsigned char* memory,
@@ skipping 14 matching lines @@
   DCHECK_IMPLIES(IsCompressedFormat(format), size_.height() % 4 == 0);
   memory_ = memory;
   format_ = format;
   return true;
 }
 
 void GLImageMemory::Destroy(bool have_context) {
   memory_ = nullptr;
 }
 
-Size GLImageMemory::GetSize() {
+gfx::Size GLImageMemory::GetSize() {
   return size_;
 }
 
 unsigned GLImageMemory::GetInternalFormat() {
   return internalformat_;
 }
 
 bool GLImageMemory::BindTexImage(unsigned target) {
   return false;
 }
 
 bool GLImageMemory::CopyTexImage(unsigned target) {
   TRACE_EVENT2("gpu", "GLImageMemory::CopyTexImage", "width", size_.width(),
                "height", size_.height());
 
   // GL_TEXTURE_EXTERNAL_OES is not a supported target.
   if (target == GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   if (IsCompressedFormat(format_)) {
     glCompressedTexImage2D(
         target, 0, TextureFormat(format_), size_.width(), size_.height(), 0,
         static_cast<GLsizei>(BufferSizeForBufferFormat(size_, format_)),
         memory_);
   } else {
     scoped_ptr<uint8_t[]> gles2_data;
     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(),
                  size_.height(), 0, data_format, data_type,
                  gles2_data ? gles2_data.get() : memory_);
   }
 
   return true;
 }
 
 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());
 
   // GL_TEXTURE_EXTERNAL_OES is not a supported target.
   if (target == GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   // Sub width is not supported.
   if (rect.width() != size_.width())
     return false;
 
   // Height must be a multiple of 4 if compressed.
   if (IsCompressedFormat(format_) && rect.height() % 4)
     return false;
 
   const uint8_t* data =
       memory_ + rect.y() * RowSizeForBufferFormat(size_.width(), format_, 0);
   if (IsCompressedFormat(format_)) {
     glCompressedTexSubImage2D(
         target, 0, offset.x(), offset.y(), rect.width(), rect.height(),
         DataFormat(format_),
         static_cast<GLsizei>(BufferSizeForBufferFormat(rect.size(), format_)),
         data);
   } else {
     GLenum data_format = DataFormat(format_);
     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);
     }
 
     glTexSubImage2D(target, 0, offset.x(), offset.y(), rect.width(),
                     rect.height(), data_format, data_type,
                     gles2_data ? gles2_data.get() : data);
   }
 
   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;
 }
 
 // static
 unsigned GLImageMemory::GetInternalFormatForTesting(BufferFormat format) {
   DCHECK(ValidFormat(format));
   return TextureFormat(format);
 }
 
-}  // namespace gfx
+}  // namespace gl