Collapsed gl query functions with their ARB/EXT variants.

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 "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 425 matching lines @@
 
   // Test id = 0 fails.
   begin_cmd.Init(
       GL_ANY_SAMPLES_PASSED_EXT, 0, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
   // Test valid parameters work.
-  EXPECT_CALL(*gl_, GenQueriesARB(1, _))
+  EXPECT_CALL(*gl_, GenQueries(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId))
       .RetiresOnSaturation();
-  EXPECT_CALL(*gl_, BeginQueryARB(GL_ANY_SAMPLES_PASSED_EXT, kNewServiceId))
+  EXPECT_CALL(*gl_, BeginQuery(GL_ANY_SAMPLES_PASSED_EXT, kNewServiceId))
       .Times(1)
       .RetiresOnSaturation();
 
   // Query object should not be created untill BeginQueriesEXT.
   QueryManager* query_manager = decoder_->GetQueryManager();
   ASSERT_TRUE(query_manager != NULL);
   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
   EXPECT_TRUE(query == NULL);
 
   // BeginQueryEXT should fail  if id is not generated from GenQueriesEXT.
@@ skipping 19 matching lines @@
   // Test trying begin again fails
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test end fails with different target
   end_cmd.Init(GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test end succeeds
-  EXPECT_CALL(*gl_, EndQueryARB(GL_ANY_SAMPLES_PASSED_EXT))
+  EXPECT_CALL(*gl_, EndQuery(GL_ANY_SAMPLES_PASSED_EXT))
       .Times(1)
       .RetiresOnSaturation();
   end_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(query->pending());
 
-  EXPECT_CALL(*gl_, DeleteQueriesARB(1, _)).Times(1).RetiresOnSaturation();
+  EXPECT_CALL(*gl_, DeleteQueries(1, _)).Times(1).RetiresOnSaturation();
 }
 
 struct QueryType {
   GLenum type;
   bool is_gl;
 };
 
 const QueryType kQueryTypes[] = {
     {GL_COMMANDS_ISSUED_CHROMIUM, false},
     {GL_LATENCY_QUERY_CHROMIUM, false},
@@ skipping 19 matching lines @@
   init.request_alpha = true;
   init.bind_generates_resource = true;
   test->InitDecoder(init);
   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
 
   BeginQueryEXT begin_cmd;
 
   test->GenHelper<GenQueriesEXTImmediate>(client_id);
 
   if (query_type.is_gl) {
-    EXPECT_CALL(*gl, GenQueriesARB(1, _))
+    EXPECT_CALL(*gl, GenQueries(1, _))
         .WillOnce(SetArgumentPointee<1>(service_id))
         .RetiresOnSaturation();
-    EXPECT_CALL(*gl, BeginQueryARB(query_type.type, service_id))
+    EXPECT_CALL(*gl, BeginQuery(query_type.type, service_id))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   // Test bad shared memory fails
   begin_cmd.Init(query_type.type, client_id, shm_id, shm_offset);
   error::Error error1 = test->ExecuteCmd(begin_cmd);
 
   if (query_type.is_gl) {
-    EXPECT_CALL(*gl, EndQueryARB(query_type.type))
+    EXPECT_CALL(*gl, EndQuery(query_type.type))
         .Times(1)
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_GET_ERROR_QUERY_CHROMIUM) {
     EXPECT_CALL(*gl, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
   }
   GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
     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))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 #endif
   }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(query_type.type, 1);
   error::Error error2 = test->ExecuteCmd(end_cmd);
 
   if (query_type.is_gl) {
     EXPECT_CALL(
-        *gl, GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
+        *gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
         .WillOnce(SetArgumentPointee<2>(1))
         .RetiresOnSaturation();
-    EXPECT_CALL(*gl, GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_EXT, _))
+    EXPECT_CALL(*gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_EXT, _))
         .WillOnce(SetArgumentPointee<2>(1))
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 #if DCHECK_IS_ON()
     EXPECT_CALL(*gl, IsSync(kGlSync))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 #endif
     EXPECT_CALL(*gl, ClientWaitSync(kGlSync, _, _))
         .WillOnce(Return(GL_ALREADY_SIGNALED))
         .RetiresOnSaturation();
   }
 
   QueryManager* query_manager = test->GetDecoder()->GetQueryManager();
   ASSERT_TRUE(query_manager != NULL);
   bool process_success = query_manager->ProcessPendingQueries(false);
 
   EXPECT_TRUE(error1 != error::kNoError || error2 != error::kNoError ||
               !process_success);
 
   if (query_type.is_gl) {
-    EXPECT_CALL(*gl, DeleteQueriesARB(1, _)).Times(1).RetiresOnSaturation();
+    EXPECT_CALL(*gl, DeleteQueries(1, _)).Times(1).RetiresOnSaturation();
   }
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 #if DCHECK_IS_ON()
     EXPECT_CALL(*gl, IsSync(kGlSync))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 #endif
     EXPECT_CALL(*gl, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
   }
   test->ResetDecoder();
@@ skipping 642 matching lines @@
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderManualInitTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES2DecoderRGBBackbufferTest,
                         ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu