Follow-up fixes to changing namespace gfx to gl.

ui/gl/test/gl_image_test_template.h

 // Copyright 2015 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.
 
 // This file defines tests that implementations of GLImage should pass in order
 // to be conformant.
 
 #ifndef UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_
 #define UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_
 
@@ skipping 33 matching lines @@
     varying vec2 v_texCoord;
     void main() {
       gl_FragColor = TextureLookup(a_texture, v_texCoord * TextureScale);
     }
   );
   const char kShaderFloatPrecision[] = STRINGIZE(
     precision mediump float;
   );
   // clang-format on
 
-  bool is_gles = gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2;
+  bool is_gles = GetGLImplementation() == kGLImplementationEGLGLES2;
   switch (target) {
     case GL_TEXTURE_2D:
-      return gl::GLHelper::LoadShader(
+      return GLHelper::LoadShader(
           GL_FRAGMENT_SHADER,
           base::StringPrintf("%s\n"
                              "#define SamplerType sampler2D\n"
                              "#define TextureLookup texture2D\n"
                              "#define TextureScale vec2(1.0, 1.0)\n"
                              "%s",
                              is_gles ? kShaderFloatPrecision : "",
                              kFragmentShader)
               .c_str());
     case GL_TEXTURE_RECTANGLE_ARB:
-      return gl::GLHelper::LoadShader(
+      return GLHelper::LoadShader(
           GL_FRAGMENT_SHADER,
           base::StringPrintf("%s\n"
                              "#extension GL_ARB_texture_rectangle : require\n"
                              "#define SamplerType sampler2DRect\n"
                              "#define TextureLookup texture2DRect\n"
                              "#define TextureScale vec2(%f, %f)\n"
                              "%s",
                              is_gles ? kShaderFloatPrecision : "",
                              static_cast<double>(size.width()),
                              static_cast<double>(size.height()),
@@ skipping 12 matching lines @@
   const char kVertexShader[] = STRINGIZE(
     attribute vec2 a_position;
     varying vec2 v_texCoord;
     void main() {
       gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);
       v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;
     }
   );
   // clang-format on
 
-  GLuint vertex_shader =
-      gl::GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
+  GLuint vertex_shader = GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
   GLuint fragment_shader = LoadFragmentShader(target, size);
-  GLuint program = gl::GLHelper::SetupProgram(vertex_shader, fragment_shader);
+  GLuint program = GLHelper::SetupProgram(vertex_shader, fragment_shader);
   EXPECT_NE(program, 0u);
   glUseProgram(program);
 
   GLint sampler_location = glGetUniformLocation(program, "a_texture");
   ASSERT_NE(sampler_location, -1);
   glUniform1i(sampler_location, 0);
 
-  GLuint vertex_buffer = gl::GLHelper::SetupQuadVertexBuffer();
-  gl::GLHelper::DrawQuad(vertex_buffer);
+  GLuint vertex_buffer = GLHelper::SetupQuadVertexBuffer();
+  GLHelper::DrawQuad(vertex_buffer);
 
   glDeleteShader(vertex_shader);
   glDeleteShader(fragment_shader);
   glDeleteProgram(program);
   glDeleteBuffersARB(1, &vertex_buffer);
 }
 
 }  // namespace
 
 template <typename GLImageTestDelegate>
 class GLImageTest : public testing::Test {
  protected:
   // Overridden from testing::Test:
   void SetUp() override {
     GLImageTestSupport::InitializeGL();
     surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
-    context_ = gl::init::CreateGLContext(nullptr, surface_.get(),
-                                         gl::PreferIntegratedGpu);
+    context_ =
+        gl::init::CreateGLContext(nullptr, surface_.get(), PreferIntegratedGpu);
     context_->MakeCurrent(surface_.get());
   }
   void TearDown() override {
     context_->ReleaseCurrent(surface_.get());
     context_ = nullptr;
     surface_ = nullptr;
     GLImageTestSupport::CleanupGL();
   }
 
  protected:
-  scoped_refptr<gl::GLSurface> surface_;
-  scoped_refptr<gl::GLContext> context_;
+  scoped_refptr<GLSurface> surface_;
+  scoped_refptr<GLContext> context_;
   GLImageTestDelegate delegate_;
 };
 
 TYPED_TEST_CASE_P(GLImageTest);
 
 TYPED_TEST_P(GLImageTest, CreateAndDestroy) {
   const gfx::Size small_image_size(4, 4);
   const gfx::Size large_image_size(512, 512);
   const uint8_t image_color[] = {0, 0xff, 0, 0xff};
 
   // Create a small solid color green image of preferred format. This must
   // succeed in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> small_image =
+  scoped_refptr<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<gl::GLImage> large_image =
+  scoped_refptr<GLImage> large_image =
       this->delegate_.CreateSolidColorImage(large_image_size, image_color);
   ASSERT_TRUE(large_image);
 
   // Verify that image size is correct.
   EXPECT_EQ(small_image->GetSize().ToString(), small_image_size.ToString());
   EXPECT_EQ(large_image->GetSize().ToString(), large_image_size.ToString());
 
   // Verify that destruction of images work correctly both when we have a
   // context and when we don't.
   small_image->Destroy(true /* have_context */);
@@ skipping 21 matching lines @@
 
   const gfx::Size image_size(256, 256);
 
   GLuint framebuffer =
       GLTestHelper::SetupFramebuffer(image_size.width(), image_size.height());
   ASSERT_TRUE(framebuffer);
   glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
   glViewport(0, 0, image_size.width(), image_size.height());
 
   // Create an uninitialized image of preferred format.
-  scoped_refptr<gl::GLImage> image = this->delegate_.CreateImage(image_size);
+  scoped_refptr<GLImage> image = this->delegate_.CreateImage(image_size);
 
   // Create a texture that |image| will be bound to.
   GLenum target = this->delegate_.GetTextureTarget();
   GLuint texture = GLTestHelper::CreateTexture(target);
   glBindTexture(target, texture);
 
   // Bind |image| to |texture|.
   bool rv = image->BindTexImage(target);
   EXPECT_TRUE(rv);
 
@@ skipping 26 matching lines @@
   const uint8_t image_color[] = {0x10, 0x20, 0, 0xff};
 
   GLuint framebuffer =
       GLTestHelper::SetupFramebuffer(image_size.width(), image_size.height());
   ASSERT_TRUE(framebuffer);
   glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
   glViewport(0, 0, image_size.width(), image_size.height());
 
   // Create a solid color green image of preferred format. This must succeed
   // in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> image =
+  scoped_refptr<GLImage> image =
       this->delegate_.CreateSolidColorImage(image_size, image_color);
   ASSERT_TRUE(image);
 
   // Initialize a blue texture of the same size as |image|.
   unsigned target = this->delegate_.GetTextureTarget();
   GLuint texture = GLTestHelper::CreateTexture(target);
   glBindTexture(target, texture);
 
   // Bind |image| to |texture|.
   bool rv = image->BindTexImage(target);
@@ skipping 30 matching lines @@
   const uint8_t texture_color[] = {0, 0, 0xff, 0xff};
 
   GLuint framebuffer =
       GLTestHelper::SetupFramebuffer(image_size.width(), image_size.height());
   ASSERT_TRUE(framebuffer);
   glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
   glViewport(0, 0, image_size.width(), image_size.height());
 
   // Create a solid color green image of preferred format. This must succeed
   // in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> image =
+  scoped_refptr<GLImage> image =
       this->delegate_.CreateSolidColorImage(image_size, image_color);
   ASSERT_TRUE(image);
 
   // Create a solid color blue texture of the same size as |image|.
   unsigned target = this->delegate_.GetTextureTarget();
   GLuint texture = GLTestHelper::CreateTexture(target);
   std::unique_ptr<uint8_t[]> pixels(new uint8_t[BufferSizeForBufferFormat(
       image_size, gfx::BufferFormat::RGBA_8888)]);
   GLImageTestSupport::SetBufferDataToColor(
       image_size.width(), image_size.height(),
@@ skipping 21 matching lines @@
   image->Destroy(true /* have_context */);
 }
 
 // The GLImageCopyTest test case verifies that the GLImage implementation
 // handles CopyTexImage correctly.
 REGISTER_TYPED_TEST_CASE_P(GLImageCopyTest, CopyTexImage);
 
 }  // namespace gl
 
 #endif  // UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_