Force time elapsed queries on certain drivers.

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 610 matching lines @@
     EXPECT_CALL(*gl, IsSync(kGlSync))
         .WillRepeatedly(Return(GL_TRUE));
 #endif
   }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(target, submit_count);
   return test->ExecuteCmd(end_cmd);
 }
 
+// Note: If the extensions GL_ARB_timer_query or GL_EXT_disjoint_timer_query are
+// loaded, timestamp queries do an implicit call of glGetQueryiv() to determine
+// if a fallback to elapsed time queries is needed. The fake timer query
+// emulates this call and returns a value such that a fallback is not needed. If
+// this method is being called with either of those extensions enabled (and not
+// GL_EXT_timer_query), set check_timestamp_bits to true on the first call and
+// set it to false on ALL subsequent calls. If using GL_EXT_timer_query,
+// check_timestamp_bits should always be false
 static error::Error ExecuteQueryCounterCmd(GLES2DecoderTestBase* test,
                                            ::gfx::MockGLInterface* gl,
                                            ::gfx::GPUTimingFake* timing_queries,
                                            GLenum target,
                                            GLuint client_id,
                                            GLuint service_id,
                                            int32_t shm_id,
                                            uint32_t shm_offset,
-                                           uint32_t submit_count) {
+                                           uint32_t submit_count,
+                                           bool check_timestamp_bits) {
   if (GL_TIMESTAMP == target) {
-    timing_queries->ExpectGPUTimeStampQuery(*gl, false);
+    timing_queries->ExpectGPUTimeStampQuery(*gl, false, check_timestamp_bits);
   }
 
   QueryCounterEXT query_counter_cmd;
   query_counter_cmd.Init(client_id,
                          target,
                          shm_id,
                          shm_offset,
                          submit_count);
   return test->ExecuteCmd(query_counter_cmd);
 }
@@ skipping 46 matching lines @@
   ::gfx::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,
-                                    client_id, service_id,
-                                    shm_id, shm_offset, 1);
+                                    query_type.type, client_id, service_id,
+                                    shm_id, shm_offset, 1, true);
   } else {
     error1 = ExecuteBeginQueryCmd(test, gl, &gpu_timing_queries,
                                   query_type.type,
                                   client_id, service_id,
                                   shm_id, shm_offset);
     error2 = ExecuteEndQueryCmd(test, gl, query_type.type, 1);
   }
 
   bool process_success = ProcessQuery(test, gl, query_type.type, service_id);
 
@@ skipping 49 matching lines @@
     init.bind_generates_resource = true;
     InitDecoder(init);
     ::testing::StrictMock< ::gfx::MockGLInterface>* gl = GetGLMock();
     ::gfx::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,
-                                                        kSharedMemoryOffset,
-                                                        1));
+      EXPECT_EQ(
+          error::kNoError,
+          ExecuteQueryCounterCmd(this, gl, &gpu_timing_queries, query_type.type,
+                                 kNewClientId, kNewServiceId, kSharedMemoryId,
+                                 kSharedMemoryOffset, 1, true));
     } else {
       EXPECT_EQ(error::kNoError, ExecuteBeginQueryCmd(this, gl,
                                                       &gpu_timing_queries,
                                                       query_type.type,
                                                       kNewClientId,
                                                       kNewServiceId,
                                                       kSharedMemoryId,
                                                       kSharedMemoryOffset));
       EXPECT_EQ(error::kNoError, ExecuteEndQueryCmd(this, gl,
                                                     query_type.type, 1));
     }
 
     EXPECT_TRUE(ProcessQuery(this, gl, query_type.type, kNewServiceId));
 
     // Reuse query.
     if (query_type.is_counter) {
-      EXPECT_EQ(error::kNoError, ExecuteQueryCounterCmd(this, gl,
-                                                        &gpu_timing_queries,
-                                                        query_type.type,
-                                                        kNewClientId,
-                                                        kNewServiceId,
-                                                        kSharedMemoryId,
-                                                        kSharedMemoryOffset,
-                                                        2));
+      EXPECT_EQ(
+          error::kNoError,
+          ExecuteQueryCounterCmd(this, gl, &gpu_timing_queries, query_type.type,
+                                 kNewClientId, kNewServiceId, kSharedMemoryId,
+                                 kSharedMemoryOffset, 2, false));
     } else {
       EXPECT_EQ(error::kNoError, ExecuteBeginQueryCmd(this, gl,
                                                       &gpu_timing_queries,
                                                       query_type.type,
                                                       kNewClientId,
                                                       kNewServiceId,
                                                       kSharedMemoryId,
                                                       kSharedMemoryOffset));
       EXPECT_EQ(error::kNoError, ExecuteEndQueryCmd(this, gl,
                                                     query_type.type, 2));
@@ skipping 200 matching lines @@
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
   EXPECT_CALL(*gl_, GenQueries(1, _))
       .WillOnce(SetArgPointee<1>(kNewServiceId))
       .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, _))
+      .WillOnce(SetArgPointee<2>(64))
+      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, QueryCounter(kNewServiceId, GL_TIMESTAMP))
       .Times(1)
       .RetiresOnSaturation();
   QueryCounterEXT query_counter_cmd;
   query_counter_cmd.Init(kNewClientId,
                          GL_TIMESTAMP,
                          kSharedMemoryId,
                          kSharedMemoryOffset,
                          1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(query_counter_cmd));
@@ skipping 506 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