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 686 matching lines @@
   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
   ::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);
+    error1 =
+        ExecuteQueryCounterCmd(test, gl, &gpu_timing_queries, query_type.type,
+                               client_id, service_id, shm_id, shm_offset, 1);
   } 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));
     } 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));
     } 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