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

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.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/gles2_cmd_decoder_unittest_base.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/test/gl_surface_test_support.h"
 
-using ::gfx::MockGLInterface;
+using ::gl::MockGLInterface;
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtMost;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
@@ skipping 131 matching lines @@
 }
 
 void GLES2DecoderTestBase::InitDecoderWithCommandLine(
     const InitState& init,
     const base::CommandLine* command_line) {
   InitState normalized_init = init;
   NormalizeInitState(&normalized_init);
   // For easier substring/extension matching
   DCHECK(normalized_init.extensions.empty() ||
          *normalized_init.extensions.rbegin() == ' ');
-  gfx::SetGLGetProcAddressProc(gfx::MockGLInterface::GetGLProcAddress);
-  gfx::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
+  gl::SetGLGetProcAddressProc(gl::MockGLInterface::GetGLProcAddress);
+  gl::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
 
   gl_.reset(new StrictMock<MockGLInterface>());
-  ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+  ::gl::MockGLInterface::SetGLInterface(gl_.get());
 
   SetupMockGLBehaviors();
 
   scoped_refptr<FeatureInfo> feature_info = new FeatureInfo;
   if (command_line) {
     GpuDriverBugWorkarounds gpu_driver_bug_workaround(command_line);
     feature_info = new FeatureInfo(*command_line, gpu_driver_bug_workaround);
   }
 
   group_ = scoped_refptr<ContextGroup>(new ContextGroup(
       gpu_preferences_, NULL, memory_tracker_,
       new ShaderTranslatorCache(gpu_preferences_),
       new FramebufferCompletenessCache, feature_info,
       normalized_init.bind_generates_resource));
   bool use_default_textures = normalized_init.bind_generates_resource;
 
   InSequence sequence;
 
-  surface_ = new gfx::GLSurfaceStub;
+  surface_ = new gl::GLSurfaceStub;
   surface_->SetSize(gfx::Size(kBackBufferWidth, kBackBufferHeight));
 
   // Context needs to be created before initializing ContextGroup, which will
   // in turn initialize FeatureInfo, which needs a context to determine
   // extension support.
   context_ = new StrictMock<GLContextMock>();
   context_->AddExtensionsString(normalized_init.extensions.c_str());
   context_->SetGLVersionString(normalized_init.gl_version.c_str());
 
   context_->GLContextStubWithExtensions::MakeCurrent(surface_.get());
-  gfx::GLSurfaceTestSupport::InitializeDynamicMockBindings(context_.get());
+  gl::GLSurfaceTestSupport::InitializeDynamicMockBindings(context_.get());
 
   TestHelper::SetupContextGroupInitExpectations(
       gl_.get(),
       DisallowedFeatures(),
       normalized_init.extensions.c_str(),
       normalized_init.gl_version.c_str(),
       normalized_init.bind_generates_resource);
 
   // We initialize the ContextGroup with a MockGLES2Decoder so that
   // we can use the ContextGroup to figure out how the real GLES2Decoder
@@ skipping 277 matching lines @@
   DoCreateProgram(client_program_id_, kServiceProgramId);
   DoCreateShader(GL_VERTEX_SHADER, client_shader_id_, kServiceShaderId);
 
   // Unsafe commands.
   bool reset_unsafe_es3_apis_enabled = false;
   if (!decoder_->unsafe_es3_apis_enabled()) {
     decoder_->set_unsafe_es3_apis_enabled(true);
     reset_unsafe_es3_apis_enabled = true;
   }
 
-  const gfx::GLVersionInfo* version = context_->GetVersionInfo();
+  const gl::GLVersionInfo* version = context_->GetVersionInfo();
   if (version->IsAtLeastGL(3, 3) || version->IsAtLeastGLES(3, 0)) {
     EXPECT_CALL(*gl_, GenSamplers(_, _))
         .WillOnce(SetArgumentPointee<1>(kServiceSamplerId))
         .RetiresOnSaturation();
     GenHelper<cmds::GenSamplersImmediate>(client_sampler_id_);
   }
   if (version->IsAtLeastGL(4, 0) || version->IsAtLeastGLES(3, 0)) {
     EXPECT_CALL(*gl_, GenTransformFeedbacks(_, _))
         .WillOnce(SetArgumentPointee<1>(kServiceTransformFeedbackId))
         .RetiresOnSaturation();
@@ skipping 39 matching lines @@
           .Times(1)
           .RetiresOnSaturation();
     }
   }
 
   decoder_->EndDecoding();
   decoder_->Destroy(!decoder_->WasContextLost());
   decoder_.reset();
   group_->Destroy(mock_decoder_.get(), false);
   engine_.reset();
-  ::gfx::MockGLInterface::SetGLInterface(NULL);
+  ::gl::MockGLInterface::SetGLInterface(NULL);
   gl_.reset();
-  gfx::ClearGLBindings();
+  gl::ClearGLBindings();
 }
 
 void GLES2DecoderTestBase::TearDown() {
   ResetDecoder();
 }
 
 void GLES2DecoderTestBase::ExpectEnableDisable(GLenum cap, bool enable) {
   if (enable) {
     EXPECT_CALL(*gl_, Enable(cap))
         .Times(1)
@@ skipping 884 matching lines @@
 
   EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(attrib, _))
         .Times(testing::AtMost(1))
         .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, _))
       .Times(1)
       .RetiresOnSaturation();
 
   if (attrib != 0 ||
-      gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
+      gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2) {
+    // TODO(bajones): Not sure if I can tell which of these will be called
+    EXPECT_CALL(*gl_, EnableVertexAttribArray(attrib))
+        .Times(testing::AtMost(1))
+        .RetiresOnSaturation();
 
-      // TODO(bajones): Not sure if I can tell which of these will be called
-      EXPECT_CALL(*gl_, EnableVertexAttribArray(attrib))
-          .Times(testing::AtMost(1))
-          .RetiresOnSaturation();
-
-      EXPECT_CALL(*gl_, DisableVertexAttribArray(attrib))
-          .Times(testing::AtMost(1))
-          .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, DisableVertexAttribArray(attrib))
+        .Times(testing::AtMost(1))
+        .RetiresOnSaturation();
   }
 }
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const int GLES2DecoderTestBase::kBackBufferWidth;
 const int GLES2DecoderTestBase::kBackBufferHeight;
 
 const GLint GLES2DecoderTestBase::kMaxTextureSize;
 const GLint GLES2DecoderTestBase::kMaxCubeMapTextureSize;
@@ skipping 579 matching lines @@
   SetupDefaultProgram();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_0_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu