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

gpu/command_buffer/service/gles2_cmd_decoder_unittest.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gpu_timing_fake.h"
 
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
-using ::gfx::MockGLInterface;
+using ::gl::MockGLInterface;
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::MatcherCast;
 using ::testing::Mock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
@@ skipping 552 matching lines @@
     {GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, false},
     {GL_GET_ERROR_QUERY_CHROMIUM, false},
     {GL_COMMANDS_COMPLETED_CHROMIUM, false},
     {GL_ANY_SAMPLES_PASSED_EXT, false},
     {GL_TIME_ELAPSED, false},
     {GL_TIMESTAMP, true},
 };
 const GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
 
 static void ExecuteGenerateQueryCmd(GLES2DecoderTestBase* test,
-                                    ::gfx::MockGLInterface* gl,
+                                    ::gl::MockGLInterface* gl,
                                     GLenum target,
                                     GLuint client_id,
                                     GLuint service_id) {
   test->GenHelper<GenQueriesEXTImmediate>(client_id);
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(*gl, GenQueries(1, _))
         .WillOnce(SetArgPointee<1>(service_id))
         .RetiresOnSaturation();
   }
 }
 
 static error::Error ExecuteBeginQueryCmd(GLES2DecoderTestBase* test,
-                                         ::gfx::MockGLInterface* gl,
-                                         ::gfx::GPUTimingFake* timing_queries,
+                                         ::gl::MockGLInterface* gl,
+                                         ::gl::GPUTimingFake* timing_queries,
                                          GLenum target,
                                          GLuint client_id,
                                          GLuint service_id,
                                          int32_t shm_id,
                                          uint32_t shm_offset) {
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(*gl, BeginQuery(target, service_id))
         .Times(1)
         .RetiresOnSaturation();
   } else if (GL_TIME_ELAPSED == target) {
     timing_queries->ExpectGPUTimerQuery(*gl, true);
   }
 
   BeginQueryEXT begin_cmd;
   begin_cmd.Init(target, client_id, shm_id, shm_offset);
   return test->ExecuteCmd(begin_cmd);
 }
 
 static error::Error ExecuteEndQueryCmd(GLES2DecoderTestBase* test,
-                                       ::gfx::MockGLInterface* gl,
+                                       ::gl::MockGLInterface* gl,
                                        GLenum target,
                                        uint32_t submit_count) {
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(*gl, EndQuery(target))
         .Times(1)
         .RetiresOnSaturation();
   } else if (GL_GET_ERROR_QUERY_CHROMIUM == target) {
     EXPECT_CALL(*gl, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
   } else if (GL_COMMANDS_COMPLETED_CHROMIUM == target) {
     EXPECT_CALL(*gl, Flush()).RetiresOnSaturation();
     EXPECT_CALL(*gl, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
         .WillOnce(Return(kGlSync))
         .RetiresOnSaturation();
 #if DCHECK_IS_ON()
     EXPECT_CALL(*gl, IsSync(kGlSync))
         .WillRepeatedly(Return(GL_TRUE));
 #endif
   }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(target, submit_count);
   return test->ExecuteCmd(end_cmd);
 }
 
 static error::Error ExecuteQueryCounterCmd(GLES2DecoderTestBase* test,
-                                           ::gfx::MockGLInterface* gl,
-                                           ::gfx::GPUTimingFake* timing_queries,
+                                           ::gl::MockGLInterface* gl,
+                                           ::gl::GPUTimingFake* timing_queries,
                                            GLenum target,
                                            GLuint client_id,
                                            GLuint service_id,
                                            int32_t shm_id,
                                            uint32_t shm_offset,
                                            uint32_t submit_count) {
   if (GL_TIMESTAMP == target) {
     timing_queries->ExpectGPUTimeStampQuery(*gl, false);
   }
 
   QueryCounterEXT query_counter_cmd;
   query_counter_cmd.Init(client_id,
                          target,
                          shm_id,
                          shm_offset,
                          submit_count);
   return test->ExecuteCmd(query_counter_cmd);
 }
 
 static bool ProcessQuery(GLES2DecoderTestBase* test,
-                         ::gfx::MockGLInterface* gl,
+                         ::gl::MockGLInterface* gl,
                          GLenum target,
                          GLuint service_id) {
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(
         *gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
         .WillOnce(SetArgPointee<2>(1))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_EXT, _))
         .WillOnce(SetArgPointee<2>(1))
         .RetiresOnSaturation();
@@ skipping 22 matching lines @@
   // context every time.
   GLES2DecoderTestBase::InitState init;
   init.extensions = "GL_EXT_occlusion_query_boolean"
                     " GL_ARB_sync"
                     " GL_ARB_timer_query";
   init.gl_version = "opengl es 3.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   test->InitDecoder(init);
-  ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
-  ::gfx::GPUTimingFake gpu_timing_queries;
+  ::testing::StrictMock<::gl::MockGLInterface>* gl = test->GetGLMock();
+  ::gl::GPUTimingFake gpu_timing_queries;
 
   ExecuteGenerateQueryCmd(test, gl, query_type.type,
                           client_id, service_id);
 
   // Test bad shared memory fails
   error::Error error1 = error::kNoError;
   error::Error error2 = error::kNoError;
   if (query_type.is_counter) {
     error1 =
         ExecuteQueryCounterCmd(test, gl, &gpu_timing_queries, query_type.type,
@@ skipping 52 matching lines @@
 
     GLES2DecoderTestBase::InitState init;
     init.extensions = "GL_EXT_occlusion_query_boolean"
                       " GL_ARB_sync"
                       " GL_ARB_timer_query";
     init.gl_version = "opengl es 3.0";
     init.has_alpha = true;
     init.request_alpha = true;
     init.bind_generates_resource = true;
     InitDecoder(init);
-    ::testing::StrictMock< ::gfx::MockGLInterface>* gl = GetGLMock();
-    ::gfx::GPUTimingFake gpu_timing_queries;
+    ::testing::StrictMock<::gl::MockGLInterface>* gl = GetGLMock();
+    ::gl::GPUTimingFake gpu_timing_queries;
 
     ExecuteGenerateQueryCmd(this, gl, query_type.type,
                             kNewClientId, kNewServiceId);
 
     // Query once.
     if (query_type.is_counter) {
       EXPECT_EQ(
           error::kNoError,
           ExecuteQueryCounterCmd(this, gl, &gpu_timing_queries, query_type.type,
                                  kNewClientId, kNewServiceId, kSharedMemoryId,
@@ skipping 894 matching lines @@
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES3DecoderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES3DecoderWithESSL3ShaderTest,
                         ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu