Add GL_CHROMIUM_get_error_query

gpu/command_buffer/service/query_manager_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/query_manager.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
-#include "gpu/command_buffer/service/common_decoder.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::InSequence;
+using ::testing::Return;
 using ::testing::SetArgumentPointee;
 
 namespace gpu {
 namespace gles2 {
 
-class MockDecoder : public CommonDecoder {
- public:
-  virtual ~MockDecoder() { }
-  MOCK_METHOD3(DoCommand, error::Error(
-     unsigned int command,
-     unsigned int arg_count,
-     const void* cmd_data));
-  MOCK_CONST_METHOD1(GetCommandName, const char* (unsigned int command_id));
-};
-
 class QueryManagerTest : public testing::Test {
  public:
   static const int32 kSharedMemoryId = 401;
   static const size_t kSharedBufferSize = 2048;
   static const uint32 kSharedMemoryOffset = 132;
   static const int32 kInvalidSharedMemoryId = 402;
   static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
   static const uint32 kInitialResult = 0xBDBDBDBDu;
   static const uint8 kInitialMemoryValue = 0xBDu;
 
   QueryManagerTest() {
   }
   ~QueryManagerTest() {
   }
 
  protected:
   virtual void SetUp() {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
     engine_.reset(new MockCommandBufferEngine());
-    decoder_.reset(new MockDecoder());
+    decoder_.reset(new MockGLES2Decoder());
     decoder_->set_engine(engine_.get());
     TestHelper::SetupFeatureInfoInitExpectations(
         gl_.get(),
         "GL_EXT_occlusion_query_boolean");
     FeatureInfo::Ref feature_info(new FeatureInfo());
     feature_info->Initialize("*");
     manager_.reset(new QueryManager(decoder_.get(), feature_info.get()));
   }
 
   virtual void TearDown() {
@@ skipping 21 matching lines @@
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, EndQueryARB(query->target()))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_TRUE(manager_->BeginQuery(query));
     EXPECT_TRUE(manager_->EndQuery(query, submit_count));
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  scoped_ptr<MockDecoder> decoder_;
+  scoped_ptr<MockGLES2Decoder> decoder_;
   scoped_ptr<QueryManager> manager_;
 
  private:
   class MockCommandBufferEngine : public CommandBufferEngine {
    public:
     MockCommandBufferEngine() {
       data_.reset(new int8[kSharedBufferSize]);
       ClearSharedMemory();
       valid_buffer_.ptr = data_.get();
       valid_buffer_.size = kSharedBufferSize;
@@ skipping 358 matching lines @@
   // Create Query.
   QueryManager::Query::Ref query(
       CreateQuery(kTarget, kClient1Id,
                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
   ASSERT_TRUE(query.get() != NULL);
 
   // Queue it
   QueueQuery(query.get(), kService1Id, kSubmitCount);
 }
 
+// Test that when based on ARB_occlusion_query2 we use GL_ANY_SAMPLES_PASSED_ARB
+// for GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT
 TEST_F(QueryManagerTest, ARBOcclusionQuery2) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT;
   const uint32 kSubmitCount = 123;
 
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(),
       "GL_ARB_occlusion_query2");
   FeatureInfo::Ref feature_info(new FeatureInfo());
@@ skipping 12 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, EndQueryARB(GL_ANY_SAMPLES_PASSED_EXT))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_TRUE(manager->BeginQuery(query));
   EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
   manager->Destroy(false);
 }
 
+// Test that when based on ARB_occlusion_query we use GL_SAMPLES_PASSED_ARB
+// for GL_ANY_SAMPLES_PASSED_EXT
 TEST_F(QueryManagerTest, ARBOcclusionQuery) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
   const uint32 kSubmitCount = 123;
 
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(),
       "GL_ARB_occlusion_query");
   FeatureInfo::Ref feature_info(new FeatureInfo());
@@ skipping 12 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, EndQueryARB(GL_SAMPLES_PASSED_ARB))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_TRUE(manager->BeginQuery(query));
   EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
   manager->Destroy(false);
 }
 
+TEST_F(QueryManagerTest, GetErrorQuery) {
+  const GLuint kClient1Id = 1;
+  const GLenum kTarget = GL_GET_ERROR_QUERY_CHROMIUM;
+  const uint32 kSubmitCount = 123;
+
+  TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), "");
+  FeatureInfo::Ref feature_info(new FeatureInfo());
+  feature_info->Initialize("*");
+  scoped_ptr<QueryManager> manager(
+      new QueryManager(decoder_.get(), feature_info.get()));
+
+  QueryManager::Query* query = manager->CreateQuery(
+      kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
+  ASSERT_TRUE(query != NULL);
+
+  // Setup shared memory like client would.
+  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
+      kSharedMemoryId, kSharedMemoryOffset, sizeof(*sync));
+  ASSERT_TRUE(sync != NULL);
+  sync->Reset();
+
+  EXPECT_TRUE(manager->BeginQuery(query));
+
+  EXPECT_CALL(*decoder_.get(), GetGLError())
+      .WillOnce(Return(GL_INVALID_ENUM))
+      .RetiresOnSaturation();
+
+  EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
+  EXPECT_FALSE(query->pending());
+
+  EXPECT_EQ(static_cast<GLuint>(GL_INVALID_ENUM), sync->result);
+
+  manager->Destroy(false);
+}
+
 }  // namespace gles2
 }  // namespace gpu