Added support for TimeStamp queries using QueryCounterEXT.

gpu/command_buffer/client/gles2_implementation_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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 394 matching lines @@
   class TestContext {
    public:
     TestContext() : commands_(NULL), token_(0) {}
 
     bool Initialize(ShareGroup* share_group,
                     bool bind_generates_resource_client,
                     bool bind_generates_resource_service,
                     bool lose_context_when_out_of_memory,
                     bool transfer_buffer_initialize_fail,
                     bool sync_query,
-                    bool occlusion_query_boolean) {
+                    bool occlusion_query_boolean,
+                    bool timer_queries) {
       command_buffer_.reset(new StrictMock<MockClientCommandBuffer>());
       if (!command_buffer_->Initialize())
         return false;
 
       transfer_buffer_.reset(
           new MockTransferBuffer(command_buffer_.get(),
                                  kTransferBufferSize,
                                  GLES2Implementation::kStartingOffset,
                                  GLES2Implementation::kAlignment,
                                  transfer_buffer_initialize_fail));
@@ skipping 24 matching lines @@
       capabilities.num_compressed_texture_formats =
           kNumCompressedTextureFormats;
       capabilities.num_shader_binary_formats = kNumShaderBinaryFormats;
       capabilities.max_transform_feedback_separate_attribs =
           kMaxTransformFeedbackSeparateAttribs;
       capabilities.max_uniform_buffer_bindings = kMaxUniformBufferBindings;
       capabilities.bind_generates_resource_chromium =
           bind_generates_resource_service ? 1 : 0;
       capabilities.sync_query = sync_query;
       capabilities.occlusion_query_boolean = occlusion_query_boolean;
+      capabilities.timer_queries = timer_queries;
       EXPECT_CALL(*gpu_control_, GetCapabilities())
           .WillOnce(testing::Return(capabilities));
 
       {
         InSequence sequence;
 
         const bool support_client_side_arrays = true;
         gl_.reset(new GLES2Implementation(helper_.get(),
                                           share_group,
                                           transfer_buffer_.get(),
@@ skipping 72 matching lines @@
     return gl_->query_tracker_->GetQuery(id);
   }
 
   struct ContextInitOptions {
     ContextInitOptions()
         : bind_generates_resource_client(true),
           bind_generates_resource_service(true),
           lose_context_when_out_of_memory(false),
           transfer_buffer_initialize_fail(false),
           sync_query(true),
-          occlusion_query_boolean(true) {}
+          occlusion_query_boolean(true),
+          timer_queries(true) {}
 
     bool bind_generates_resource_client;
     bool bind_generates_resource_service;
     bool lose_context_when_out_of_memory;
     bool transfer_buffer_initialize_fail;
     bool sync_query;
     bool occlusion_query_boolean;
+    bool timer_queries;
   };
 
   bool Initialize(const ContextInitOptions& init_options) {
     bool success = true;
     share_group_ = new ShareGroup(init_options.bind_generates_resource_client);
 
     for (int i = 0; i < kNumTestContexts; i++) {
       if (!test_contexts_[i].Initialize(
               share_group_.get(),
               init_options.bind_generates_resource_client,
               init_options.bind_generates_resource_service,
               init_options.lose_context_when_out_of_memory,
               init_options.transfer_buffer_initialize_fail,
               init_options.sync_query,
-              init_options.occlusion_query_boolean))
+              init_options.occlusion_query_boolean,
+              init_options.timer_queries))
         success = false;
     }
 
     // Default to test context 0.
     gpu_control_ = test_contexts_[0].gpu_control_.get();
     helper_ = test_contexts_[0].helper_.get();
     transfer_buffer_ = test_contexts_[0].transfer_buffer_.get();
     gl_ = test_contexts_[0].gl_.get();
     commands_ = test_contexts_[0].commands_;
     return success;
@@ skipping 2625 matching lines @@
   // Test GetQueryObjectui64vEXT CheckResultsAvailable
   ClearCommands();
   gl_->GetQueryObjectui64vEXT(id1, GL_QUERY_RESULT_AVAILABLE_EXT, &available2);
   EXPECT_EQ(0u, available2);
 }
 
 TEST_F(GLES2ImplementationManualInitTest, BadQueryTargets) {
   ContextInitOptions init_options;
   init_options.sync_query = false;
   init_options.occlusion_query_boolean = false;
+  init_options.timer_queries = false;
   ASSERT_TRUE(Initialize(init_options));
 
   GLuint id = 0;
   gl_->GenQueriesEXT(1, &id);
   ClearCommands();
 
   gl_->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, id);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_EQ(nullptr, GetQuery(id));
 
   gl_->BeginQueryEXT(GL_ANY_SAMPLES_PASSED, id);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_EQ(nullptr, GetQuery(id));
 
   gl_->BeginQueryEXT(GL_ANY_SAMPLES_PASSED_CONSERVATIVE, id);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_EQ(nullptr, GetQuery(id));
 
+  gl_->BeginQueryEXT(GL_TIME_ELAPSED_EXT, id);
+  EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
+  EXPECT_EQ(nullptr, GetQuery(id));
+
   gl_->BeginQueryEXT(0x123, id);
+  EXPECT_EQ(GL_INVALID_ENUM, CheckError());
+  EXPECT_EQ(nullptr, GetQuery(id));
+
+  gl_->QueryCounterEXT(id, GL_TIMESTAMP_EXT);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_EQ(nullptr, GetQuery(id));
+
+  gl_->QueryCounterEXT(id, 0x123);
+  EXPECT_EQ(GL_INVALID_ENUM, CheckError());
+  EXPECT_EQ(nullptr, GetQuery(id));
 }
 
+TEST_F(GLES2ImplementationTest, QueryCounterEXT) {
+  GLuint expected_ids[2] = { 1, 2 }; // These must match what's actually genned.
+  struct GenCmds {
+    cmds::GenQueriesEXTImmediate gen;
+    GLuint data[2];
+  };
+  GenCmds expected_gen_cmds;
+  expected_gen_cmds.gen.Init(arraysize(expected_ids), &expected_ids[0]);
+  GLuint ids[arraysize(expected_ids)] = { 0, };
+  gl_->GenQueriesEXT(arraysize(expected_ids), &ids[0]);
+  EXPECT_EQ(0, memcmp(
+      &expected_gen_cmds, commands_, sizeof(expected_gen_cmds)));
+  GLuint id1 = ids[0];
+  GLuint id2 = ids[1];
+  ClearCommands();
+
+  // Test QueryCounterEXT fails if id = 0.
+  gl_->QueryCounterEXT(0, GL_TIMESTAMP_EXT);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
+
+  // Test QueryCounterEXT fails if target is unknown.
+  ClearCommands();
+  gl_->QueryCounterEXT(id1, GL_TIME_ELAPSED_EXT);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_ENUM, CheckError());
+
+  // Test QueryCounterEXT inserts command.
+  struct QueryCounterCmds {
+    cmds::QueryCounterEXT query_counter;
+  };
+  QueryCounterCmds expected_query_counter_cmds;
+  const void* commands = GetPut();
+  gl_->QueryCounterEXT(id1, GL_TIMESTAMP_EXT);
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+  QueryTracker::Query* query = GetQuery(id1);
+  ASSERT_TRUE(query != NULL);
+  expected_query_counter_cmds.query_counter.Init(
+      GL_TIMESTAMP_EXT, id1, query->shm_id(), query->shm_offset(),
+      query->submit_count());
+  EXPECT_EQ(0, memcmp(&expected_query_counter_cmds, commands,
+                      sizeof(expected_query_counter_cmds)));
+  ClearCommands();
+
+  // Test 2nd QueryCounterEXT succeeds.
+  commands = GetPut();
+  gl_->QueryCounterEXT(id2, GL_TIMESTAMP_EXT);
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+  QueryTracker::Query* query2 = GetQuery(id2);
+  ASSERT_TRUE(query2 != NULL);
+  expected_query_counter_cmds.query_counter.Init(
+      GL_TIMESTAMP_EXT, id2, query2->shm_id(), query2->shm_offset(),
+      query2->submit_count());
+  EXPECT_EQ(0, memcmp(&expected_query_counter_cmds, commands,
+                      sizeof(expected_query_counter_cmds)));
+  ClearCommands();
+
+  // Test QueryCounterEXT increments count.
+  base::subtle::Atomic32 old_submit_count = query->submit_count();
+  commands = GetPut();
+  gl_->QueryCounterEXT(id1, GL_TIMESTAMP_EXT);
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+  EXPECT_NE(old_submit_count, query->submit_count());
+  expected_query_counter_cmds.query_counter.Init(
+      GL_TIMESTAMP_EXT, id1, query->shm_id(), query->shm_offset(),
+      query->submit_count());
+  EXPECT_EQ(0, memcmp(&expected_query_counter_cmds, commands,
+                      sizeof(expected_query_counter_cmds)));
+  ClearCommands();
+
+  // Test GetQueryObjectuivEXT CheckResultsAvailable
+  GLuint available = 0xBDu;
+  ClearCommands();
+  gl_->GetQueryObjectuivEXT(id1, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
+  EXPECT_EQ(0u, available);
+
+  // Test GetQueryObjectui64vEXT CheckResultsAvailable
+  GLuint64 available2 = 0xBDu;
+  ClearCommands();
+  gl_->GetQueryObjectui64vEXT(id1, GL_QUERY_RESULT_AVAILABLE_EXT, &available2);
+  EXPECT_EQ(0u, available2);
+}
+
 TEST_F(GLES2ImplementationTest, ErrorQuery) {
   GLuint id = 0;
   gl_->GenQueriesEXT(1, &id);
   ClearCommands();
 
   // Test BeginQueryEXT does NOT insert commands.
   gl_->BeginQueryEXT(GL_GET_ERROR_QUERY_CHROMIUM, id);
   EXPECT_TRUE(NoCommandsWritten());
   QueryTracker::Query* query = GetQuery(id);
   ASSERT_TRUE(query != NULL);
@@ skipping 607 matching lines @@
 TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu