Implement GL_EXT_occlusion_query_boolean on OSX

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/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::SetArgumentPointee;
 
 namespace gpu {
 namespace gles2 {
 
 class MockDecoder : public CommonDecoder {
@@ skipping 21 matching lines @@
   ~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_->set_engine(engine_.get());
-    manager_.reset(new QueryManager(decoder_.get(), false));
+    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() {
     decoder_.reset();
     manager_->Destroy(false);
     manager_.reset();
     engine_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
@@ skipping 146 matching lines @@
   EXPECT_EQ(kTarget, query->target());
   EXPECT_EQ(kSharedMemoryId, query->shm_id());
   EXPECT_EQ(kSharedMemoryOffset, query->shm_offset());
 }
 
 TEST_F(QueryManagerTest, ProcessPendingQuery) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
   const uint32 kSubmitCount = 123;
-  const GLuint kResult = 456;
+  const GLuint kResult = 1;
 
   // Check nothing happens if there are no pending queries.
   EXPECT_TRUE(manager_->ProcessPendingQueries());
 
   // Create Query.
   QueryManager::Query::Ref query(
       CreateQuery(kTarget, kClient1Id,
                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
   ASSERT_TRUE(query.get() != NULL);
 
@@ skipping 44 matching lines @@
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   const GLuint kService2Id = 12;
   const GLuint kClient3Id = 3;
   const GLuint kService3Id = 13;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
   const uint32 kSubmitCount1 = 123;
   const uint32 kSubmitCount2 = 123;
   const uint32 kSubmitCount3 = 123;
-  const GLuint kResult1 = 456;
-  const GLuint kResult2 = 457;
-  const GLuint kResult3 = 458;
+  const GLuint kResult1 = 1;
+  const GLuint kResult2 = 1;
+  const GLuint kResult3 = 1;
 
   // Setup shared memory like client would.
   QuerySync* sync1 = decoder_->GetSharedMemoryAs<QuerySync*>(
       kSharedMemoryId, kSharedMemoryOffset, sizeof(*sync1) * 3);
   ASSERT_TRUE(sync1 != NULL);
   QuerySync* sync2 = sync1 + 1;
   QuerySync* sync3 = sync2 + 1;
 
   // Create Queries.
   QueryManager::Query::Ref query1(
@@ skipping 90 matching lines @@
   EXPECT_EQ(kSubmitCount3, sync3->process_count);
   EXPECT_EQ(kResult3, sync3->result);
   EXPECT_FALSE(manager_->HavePendingQueries());
 }
 
 TEST_F(QueryManagerTest, ProcessPendingBadSharedMemoryId) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
   const uint32 kSubmitCount = 123;
-  const GLuint kResult = 456;
+  const GLuint kResult = 1;
 
   // Create Query.
   QueryManager::Query::Ref query(
       CreateQuery(kTarget, kClient1Id,
                   kInvalidSharedMemoryId, kSharedMemoryOffset, kService1Id));
   ASSERT_TRUE(query.get() != NULL);
 
   // Queue it
   QueueQuery(query.get(), kService1Id, kSubmitCount);
 
   // Process with return available.
   // Expect 2 GL commands.
   EXPECT_CALL(*gl_,
       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
       .WillOnce(SetArgumentPointee<2>(1))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_EXT, _))
       .WillOnce(SetArgumentPointee<2>(kResult))
       .RetiresOnSaturation();
   EXPECT_FALSE(manager_->ProcessPendingQueries());
 }
 
 TEST_F(QueryManagerTest, ProcessPendingBadSharedMemoryOffset) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
   const uint32 kSubmitCount = 123;
-  const GLuint kResult = 456;
+  const GLuint kResult = 1;
 
   // Create Query.
   QueryManager::Query::Ref query(
       CreateQuery(kTarget, kClient1Id,
                   kSharedMemoryId, kInvalidSharedMemoryOffset, kService1Id));
   ASSERT_TRUE(query.get() != NULL);
 
   // Queue it
   QueueQuery(query.get(), kService1Id, kSubmitCount);
 
@@ skipping 25 matching lines @@
   // Queue it
   QueueQuery(query.get(), kService1Id, kSubmitCount);
 }
 
 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;
 
-  scoped_ptr<QueryManager> manager(new QueryManager(decoder_.get(), true));
+  TestHelper::SetupFeatureInfoInitExpectations(
+      gl_.get(),
+      "GL_ARB_occlusion_query2");
+  FeatureInfo::Ref feature_info(new FeatureInfo());
+  feature_info->Initialize("*");
+  scoped_ptr<QueryManager> manager(
+      new QueryManager(decoder_.get(), feature_info.get()));
 
   EXPECT_CALL(*gl_, GenQueriesARB(1, _))
      .WillOnce(SetArgumentPointee<1>(kService1Id))
      .RetiresOnSaturation();
   QueryManager::Query* query = manager->CreateQuery(
       kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
   ASSERT_TRUE(query != NULL);
 
   EXPECT_CALL(*gl_, BeginQueryARB(GL_ANY_SAMPLES_PASSED_EXT, kService1Id))
       .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_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());
+  feature_info->Initialize("*");
+  scoped_ptr<QueryManager> manager(
+      new QueryManager(decoder_.get(), feature_info.get()));
+
+  EXPECT_CALL(*gl_, GenQueriesARB(1, _))
+     .WillOnce(SetArgumentPointee<1>(kService1Id))
+     .RetiresOnSaturation();
+  QueryManager::Query* query = manager->CreateQuery(
+      kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
+  ASSERT_TRUE(query != NULL);
+
+  EXPECT_CALL(*gl_, BeginQueryARB(GL_SAMPLES_PASSED_ARB, kService1Id))
+      .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);
+}
+
 }  // namespace gles2
 }  // namespace gpu