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

gpu/command_buffer/service/test_helper.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/test_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 84 matching lines @@
 const GLint TestHelper::kMaxProgramTexelOffset;
 const GLint TestHelper::kMinProgramTexelOffset;
 const GLint TestHelper::kMaxTransformFeedbackSeparateAttribs;
 const GLint TestHelper::kMaxUniformBufferBindings;
 const GLint TestHelper::kUniformBufferOffsetAlignment;
 #endif
 
 std::vector<std::string> TestHelper::split_extensions_;
 
 void TestHelper::SetupTextureInitializationExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     GLenum target,
     bool use_default_textures) {
   InSequence sequence;
 
   bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
   bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
   bool is_3d_or_2d_array_target = (target == GL_TEXTURE_3D ||
       target == GL_TEXTURE_2D_ARRAY);
 
   static GLuint texture_2d_ids[] = {
@@ skipping 79 matching lines @@
         }
       }
     }
   }
   EXPECT_CALL(*gl, BindTexture(target, 0))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupTextureManagerInitExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     bool is_es3_enabled,
     bool is_desktop_core_profile,
     const char* extensions,
     bool use_default_textures) {
   InSequence sequence;
 
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
@@ skipping 23 matching lines @@
     SetupTextureInitializationExpectations(
         gl, GL_TEXTURE_EXTERNAL_OES, use_default_textures);
   }
   if (arb_texture_rectangle) {
     SetupTextureInitializationExpectations(
         gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures);
   }
 }
 
 void TestHelper::SetupTextureDestructionExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     GLenum target,
     bool use_default_textures) {
   if (!use_default_textures)
     return;
 
   GLuint texture_id = 0;
   switch (target) {
     case GL_TEXTURE_2D:
       texture_id = kServiceDefaultTexture2dId;
       break;
@@ skipping 15 matching lines @@
     default:
       NOTREACHED();
   }
 
   EXPECT_CALL(*gl, DeleteTextures(1, Pointee(texture_id)))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupTextureManagerDestructionExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     bool is_es3_enabled,
     bool is_desktop_core_profile,
     const char* extensions,
     bool use_default_textures) {
   SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureDestructionExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
   if (is_es3_enabled) {
     SetupTextureDestructionExpectations(
@@ skipping 24 matching lines @@
     SetupTextureDestructionExpectations(
         gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures);
   }
 
   EXPECT_CALL(*gl, DeleteTextures(TextureManager::kNumDefaultTextures, _))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupContextGroupInitExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     const DisallowedFeatures& disallowed_features,
     const char* extensions,
     const char* gl_version,
     bool bind_generates_resource) {
   InSequence sequence;
 
   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", gl_version);
 
-  gfx::GLVersionInfo gl_info(gl_version, "", extensions);
+  gl::GLVersionInfo gl_info(gl_version, "", extensions);
 
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, _))
       .WillOnce(SetArgumentPointee<1>(kMaxRenderbufferSize))
       .RetiresOnSaturation();
   if (strstr(extensions, "GL_EXT_framebuffer_multisample") ||
       strstr(extensions, "GL_EXT_multisampled_render_to_texture") ||
       gl_info.is_es3 || gl_info.is_desktop_core_profile) {
     EXPECT_CALL(*gl, GetIntegerv(GL_MAX_SAMPLES, _))
         .WillOnce(SetArgumentPointee<1>(kMaxSamples))
         .RetiresOnSaturation();
@@ skipping 109 matching lines @@
       .Times(testing::Between(0, 1))
       .WillRepeatedly(SetArgumentPointee<1>(kMinProgramTexelOffset))
       .RetiresOnSaturation();
 
   bool use_default_textures = bind_generates_resource;
   SetupTextureManagerInitExpectations(
       gl, false, gl_info.is_desktop_core_profile, extensions,
       use_default_textures);
 }
 
-void TestHelper::SetupFeatureInfoInitExpectations(
-      ::gfx::MockGLInterface* gl, const char* extensions) {
+void TestHelper::SetupFeatureInfoInitExpectations(::gl::MockGLInterface* gl,
+                                                  const char* extensions) {
   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", "");
 }
 
 void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
-     ::gfx::MockGLInterface* gl,
-     const char* extensions,
-     const char* gl_renderer,
-     const char* gl_version,
-     bool enable_es3) {
+    ::gl::MockGLInterface* gl,
+    const char* extensions,
+    const char* gl_renderer,
+    const char* gl_version,
+    bool enable_es3) {
   InSequence sequence;
 
   EXPECT_CALL(*gl, GetString(GL_VERSION))
       .WillOnce(Return(reinterpret_cast<const uint8_t*>(gl_version)))
       .RetiresOnSaturation();
 
   // Persistent storage is needed for the split extension string.
   split_extensions_.clear();
   if (extensions) {
     split_extensions_ = base::SplitString(
         extensions, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   }
 
-  gfx::GLVersionInfo gl_info(gl_version, gl_renderer, extensions);
+  gl::GLVersionInfo gl_info(gl_version, gl_renderer, extensions);
   if (!gl_info.is_es && gl_info.major_version >= 3) {
     EXPECT_CALL(*gl, GetIntegerv(GL_NUM_EXTENSIONS, _))
         .WillOnce(SetArgumentPointee<1>(split_extensions_.size()))
         .RetiresOnSaturation();
     for (size_t ii = 0; ii < split_extensions_.size(); ++ii) {
       EXPECT_CALL(*gl, GetStringi(GL_EXTENSIONS, ii))
           .WillOnce(Return(
               reinterpret_cast<const uint8_t*>(split_extensions_[ii].c_str())))
           .RetiresOnSaturation();
     }
@@ skipping 188 matching lines @@
         .Times(1)
         .RetiresOnSaturation();
 #if DCHECK_IS_ON()
     EXPECT_CALL(*gl, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
 #endif
   }
 }
 
-void TestHelper::SetupExpectationsForClearingUniforms(
-    ::gfx::MockGLInterface* gl, UniformInfo* uniforms, size_t num_uniforms) {
+void TestHelper::SetupExpectationsForClearingUniforms(::gl::MockGLInterface* gl,
+                                                      UniformInfo* uniforms,
+                                                      size_t num_uniforms) {
   for (size_t ii = 0; ii < num_uniforms; ++ii) {
     const UniformInfo& info = uniforms[ii];
     switch (info.type) {
     case GL_FLOAT:
       EXPECT_CALL(*gl, Uniform1fv(info.real_location, info.size, _))
           .Times(1)
           .RetiresOnSaturation();
       break;
     case GL_FLOAT_VEC2:
       EXPECT_CALL(*gl, Uniform2fv(info.real_location, info.size, _))
@@ skipping 79 matching lines @@
           .RetiresOnSaturation();
       break;
     default:
       NOTREACHED();
       break;
     }
   }
 }
 
 void TestHelper::SetupProgramSuccessExpectations(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     const FeatureInfo* feature_info,
     AttribInfo* attribs,
     size_t num_attribs,
     UniformInfo* uniforms,
     size_t num_uniforms,
     VaryingInfo* varyings,
     size_t num_varyings,
     ProgramOutputInfo* program_outputs,
     size_t num_program_outputs,
     GLuint service_id) {
@@ skipping 144 matching lines @@
             .RetiresOnSaturation();
       } else {
         // Test case must not use indices, or the context of the testcase has to
         // support the dual source blending.
         DCHECK(info.index == 0);
       }
     }
   }
 }
 
-void TestHelper::SetupShaderExpectations(::gfx::MockGLInterface* gl,
+void TestHelper::SetupShaderExpectations(::gl::MockGLInterface* gl,
                                          const FeatureInfo* feature_info,
                                          AttribInfo* attribs,
                                          size_t num_attribs,
                                          UniformInfo* uniforms,
                                          size_t num_uniforms,
                                          GLuint service_id) {
   InSequence s;
 
   EXPECT_CALL(*gl, LinkProgram(service_id)).Times(1).RetiresOnSaturation();
 
   SetupProgramSuccessExpectations(gl, feature_info, attribs, num_attribs,
                                   uniforms, num_uniforms, nullptr, 0, nullptr,
                                   0, service_id);
 }
 
 void TestHelper::SetupShaderExpectationsWithVaryings(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     const FeatureInfo* feature_info,
     AttribInfo* attribs,
     size_t num_attribs,
     UniformInfo* uniforms,
     size_t num_uniforms,
     VaryingInfo* varyings,
     size_t num_varyings,
     ProgramOutputInfo* program_outputs,
     size_t num_program_outputs,
     GLuint service_id) {
   InSequence s;
 
   EXPECT_CALL(*gl,
       LinkProgram(service_id))
       .Times(1)
       .RetiresOnSaturation();
 
   SetupProgramSuccessExpectations(
       gl, feature_info, attribs, num_attribs, uniforms, num_uniforms, varyings,
       num_varyings, program_outputs, num_program_outputs, service_id);
 }
 
-void TestHelper::DoBufferData(
-    ::gfx::MockGLInterface* gl, MockErrorState* error_state,
-    BufferManager* manager, Buffer* buffer, GLenum target, GLsizeiptr size,
-    GLenum usage, const GLvoid* data, GLenum error) {
+void TestHelper::DoBufferData(::gl::MockGLInterface* gl,
+                              MockErrorState* error_state,
+                              BufferManager* manager,
+                              Buffer* buffer,
+                              GLenum target,
+                              GLsizeiptr size,
+                              GLenum usage,
+                              const GLvoid* data,
+                              GLenum error) {
   EXPECT_CALL(*error_state, CopyRealGLErrorsToWrapper(_, _, _))
       .Times(1)
       .RetiresOnSaturation();
   if (manager->IsUsageClientSideArray(usage)) {
     EXPECT_CALL(*gl, BufferData(target, 0, _, usage))
         .Times(1)
         .RetiresOnSaturation();
   } else {
     EXPECT_CALL(*gl, BufferData(target, size, _, usage))
         .Times(1)
         .RetiresOnSaturation();
   }
   EXPECT_CALL(*error_state, PeekGLError(_, _, _))
       .WillOnce(Return(error))
       .RetiresOnSaturation();
   manager->DoBufferData(error_state, buffer, target, size, usage, data);
 }
 
-void TestHelper::SetTexParameteriWithExpectations(
-    ::gfx::MockGLInterface* gl, MockErrorState* error_state,
-    TextureManager* manager, TextureRef* texture_ref,
-    GLenum pname, GLint value, GLenum error) {
+void TestHelper::SetTexParameteriWithExpectations(::gl::MockGLInterface* gl,
+                                                  MockErrorState* error_state,
+                                                  TextureManager* manager,
+                                                  TextureRef* texture_ref,
+                                                  GLenum pname,
+                                                  GLint value,
+                                                  GLenum error) {
   if (error == GL_NO_ERROR) {
     EXPECT_CALL(*gl, TexParameteri(texture_ref->texture()->target(),
                                    pname, value))
         .Times(1)
         .RetiresOnSaturation();
   } else if (error == GL_INVALID_ENUM) {
     EXPECT_CALL(*error_state, SetGLErrorInvalidEnum(_, _, _, value, _))
         .Times(1)
         .RetiresOnSaturation();
   } else {
     EXPECT_CALL(*error_state, SetGLErrorInvalidParami(_, _, error, _, _, _))
         .Times(1)
         .RetiresOnSaturation();
   }
   manager->SetParameteri("", error_state, texture_ref, pname, value);
 }
 
 // static
 void TestHelper::SetShaderStates(
-    ::gfx::MockGLInterface* gl,
+    ::gl::MockGLInterface* gl,
     Shader* shader,
     bool expected_valid,
     const std::string* const expected_log_info,
     const std::string* const expected_translated_source,
     const int* const expected_shader_version,
     const AttributeMap* const expected_attrib_map,
     const UniformMap* const expected_uniform_map,
     const VaryingMap* const expected_varying_map,
     const InterfaceBlockMap* const expected_interface_block_map,
     const OutputVariableList* const expected_output_variable_list,
@@ skipping 63 matching lines @@
                                  GL_COMPILE_STATUS,
                                  NotNull()))  // status
         .WillOnce(SetArgumentPointee<2>(GL_TRUE))
         .RetiresOnSaturation();
   }
   shader->RequestCompile(translator, Shader::kGL);
   shader->DoCompile();
 }
 
 // static
-void TestHelper::SetShaderStates(
-      ::gfx::MockGLInterface* gl, Shader* shader, bool valid) {
+void TestHelper::SetShaderStates(::gl::MockGLInterface* gl,
+                                 Shader* shader,
+                                 bool valid) {
   SetShaderStates(gl, shader, valid, nullptr, nullptr, nullptr, nullptr,
                   nullptr, nullptr, nullptr, nullptr, nullptr);
 }
 
 // static
 sh::Attribute TestHelper::ConstructAttribute(
     GLenum type, GLint array_size, GLenum precision,
     bool static_use, const std::string& name) {
   return ConstructShaderVariable<sh::Attribute>(
       type, array_size, precision, static_use, name);
@@ skipping 19 matching lines @@
     GLenum type,
     GLint array_size,
     GLenum precision,
     bool static_use,
     const std::string& name) {
   return ConstructShaderVariable<sh::OutputVariable>(
       type, array_size, precision, static_use, name);
 }
 
 ScopedGLImplementationSetter::ScopedGLImplementationSetter(
-    gfx::GLImplementation implementation)
-    : old_implementation_(gfx::GetGLImplementation()) {
-  gfx::SetGLImplementation(implementation);
+    gl::GLImplementation implementation)
+    : old_implementation_(gl::GetGLImplementation()) {
+  gl::SetGLImplementation(implementation);
 }
 
 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() {
-  gfx::SetGLImplementation(old_implementation_);
+  gl::SetGLImplementation(old_implementation_);
 }
 
 }  // namespace gles2
 }  // namespace gpu