Force time elapsed queries on certain drivers.

ui/gl/gpu_timing_fake.cc

 // Copyright 2015 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 "ui/gl/gpu_timing_fake.h"
 
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
 namespace gfx {
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::AtMost;
 using ::testing::Exactly;
 using ::testing::Invoke;
 using ::testing::NotNull;
+using ::testing::DoAll;
+using ::testing::Return;
+using ::testing::SetArgPointee;
 
 int64_t GPUTimingFake::fake_cpu_time_ = 0;
 
 GPUTimingFake::GPUTimingFake() {
   Reset();
 }
 
 GPUTimingFake::~GPUTimingFake() {
 }
 
@@ skipping 39 matching lines @@
 
 void GPUTimingFake::ExpectDisjointCalls(MockGLInterface& gl) {
   EXPECT_CALL(gl, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(AtLeast(1))
       .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLGetIntegerv));
 }
 
 void GPUTimingFake::ExpectNoDisjointCalls(MockGLInterface& gl) {
   EXPECT_CALL(gl, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(Exactly(0));
 }
 
-void GPUTimingFake::ExpectGPUTimeStampQuery(
-    MockGLInterface& gl, bool elapsed_query) {
+void GPUTimingFake::ExpectGPUTimeStampQuery(MockGLInterface& gl,
+                                            bool elapsed_query,
+                                            bool query_timestamp_counter_bits) {

[David Yen, 2016/02/17 19:04:55]

Whether or not timestamp counter bits is actually queries is leaking too much
implementation detail, we would basically have to update that boolean as we
update our implementation. Since we don't really particularly care about it just
do an EXPECT_CALL at the top of the function just like the "GenQueries" at the
top and make it always set it to 64 (IE. Copy and paste the code above and
remove ".Times(Exactly(1))"). This makes it so you don't have to change anything
else either.

If we end up writing a test that does test we do the right thing when the query
counter bits is 0, we can just write a test that mocks that function within the
test itself.

[Ian Ewell, 2016/02/17 21:06:30]

Done.

   EXPECT_CALL(gl, GenQueries(1, NotNull())).Times(Exactly(1))
       .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLGenQueries));
 
   if (!elapsed_query) {
     // Time Stamp based queries.
+    if (query_timestamp_counter_bits) {
+      EXPECT_CALL(gl,
+                  GetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, NotNull()))
+          .Times(Exactly(1))
+          .WillRepeatedly(DoAll(SetArgPointee<2>(64), Return()));
+    }
     EXPECT_CALL(gl, GetInteger64v(GL_TIMESTAMP, _))
         .WillRepeatedly(
             Invoke(this, &GPUTimingFake::FakeGLGetInteger64v));
 
     EXPECT_CALL(gl, QueryCounter(_, GL_TIMESTAMP)).Times(Exactly(1))
         .WillRepeatedly(
              Invoke(this, &GPUTimingFake::FakeGLQueryCounter));
   } else {
     // Time Elapsed based queries.
+    if (query_timestamp_counter_bits) {
+      EXPECT_CALL(gl,
+                  GetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, NotNull()))
+          .Times(Exactly(1))
+          .WillRepeatedly(DoAll(SetArgPointee<2>(0), Return()));
+    }
     EXPECT_CALL(gl, BeginQuery(GL_TIME_ELAPSED, _)).Times(Exactly(1))
         .WillRepeatedly(
             Invoke(this, &GPUTimingFake::FakeGLBeginQuery));
 
     EXPECT_CALL(gl, EndQuery(GL_TIME_ELAPSED)).Times(Exactly(1))
       .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLEndQuery));
   }
 
   EXPECT_CALL(gl, GetQueryObjectuiv(_, GL_QUERY_RESULT_AVAILABLE,
                                     NotNull()))
@@ skipping 10 matching lines @@
 }
 
 void GPUTimingFake::ExpectGPUTimerQuery(
     MockGLInterface& gl, bool elapsed_query) {
   EXPECT_CALL(gl, GenQueries(1, NotNull()))
       .Times(AtLeast(elapsed_query ? 1 : 2))
       .WillRepeatedly(Invoke(this, &GPUTimingFake::FakeGLGenQueries));
 
   if (!elapsed_query) {
     // Time Stamp based queries.
+    EXPECT_CALL(gl, GetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, NotNull()))
+        .Times(Exactly(1))
+        .WillRepeatedly(DoAll(SetArgPointee<2>(64), Return()));
+
     EXPECT_CALL(gl, GetInteger64v(GL_TIMESTAMP, _))
         .WillRepeatedly(
             Invoke(this, &GPUTimingFake::FakeGLGetInteger64v));
 
     EXPECT_CALL(gl, QueryCounter(_, GL_TIMESTAMP)).Times(AtLeast(1))
         .WillRepeatedly(
              Invoke(this, &GPUTimingFake::FakeGLQueryCounter));
   }
 
   // Time Elapsed based queries.
@@ skipping 147 matching lines @@
     default:
       FAIL() << "Invalid variable passed to GetIntegerv: " << pname;
   }
 }
 
 GLenum GPUTimingFake::FakeGLGetError() {
   return GL_NO_ERROR;
 }
 
 }  // namespace gfx