src/gpu/command_buffer/service/query_manager_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/query_manager.h"
   6 #include "gpu/command_buffer/common/gles2_cmd_format.h"
   7 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
   8 #include "gpu/command_buffer/service/error_state_mock.h"
   9 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  10 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
  11 #include "gpu/command_buffer/service/feature_info.h"
  12 #include "gpu/command_buffer/service/test_helper.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "ui/gl/gl_mock.h"
  15
  16 using ::testing::_;
  17 using ::testing::InSequence;
  18 using ::testing::Return;
  19 using ::testing::SetArgumentPointee;
  20
  21 namespace gpu {
  22 namespace gles2 {
  23
  24 class QueryManagerTest : public testing::Test {
  25  public:
  26   static const int32 kSharedMemoryId = 401;
  27   static const size_t kSharedBufferSize = 2048;
  28   static const uint32 kSharedMemoryOffset = 132;
  29   static const int32 kInvalidSharedMemoryId = 402;
  30   static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
  31   static const uint32 kInitialResult = 0xBDBDBDBDu;
  32   static const uint8 kInitialMemoryValue = 0xBDu;
  33
  34   QueryManagerTest() {
  35   }
  36   virtual ~QueryManagerTest() {
  37   }
  38
  39  protected:
  40   virtual void SetUp() {
  41     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
  42     ::gfx::MockGLInterface::SetGLInterface(gl_.get());
  43     engine_.reset(new MockCommandBufferEngine());
  44     decoder_.reset(new MockGLES2Decoder());
  45     decoder_->set_engine(engine_.get());
  46     TestHelper::SetupFeatureInfoInitExpectations(
  47         gl_.get(),
  48         "GL_EXT_occlusion_query_boolean");
  49     scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  50     feature_info->Initialize();
  51     manager_.reset(new QueryManager(decoder_.get(), feature_info.get()));
  52   }
  53
  54   virtual void TearDown() {
  55     decoder_.reset();
  56     manager_->Destroy(false);
  57     manager_.reset();
  58     engine_.reset();
  59     ::gfx::MockGLInterface::SetGLInterface(NULL);
  60     gl_.reset();
  61   }
  62
  63   QueryManager::Query* CreateQuery(
  64       GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset,
  65       GLuint service_id) {
  66     EXPECT_CALL(*gl_, GenQueriesARB(1, _))
  67        .WillOnce(SetArgumentPointee<1>(service_id))
  68        .RetiresOnSaturation();
  69     return manager_->CreateQuery(target, client_id, shm_id, shm_offset);
  70   }
  71
  72   void QueueQuery(QueryManager::Query* query,
  73                   GLuint service_id,
  74                   base::subtle::Atomic32 submit_count) {
  75     EXPECT_CALL(*gl_, BeginQueryARB(query->target(), service_id))
  76         .Times(1)
  77         .RetiresOnSaturation();
  78     EXPECT_CALL(*gl_, EndQueryARB(query->target()))
  79         .Times(1)
  80         .RetiresOnSaturation();
  81     EXPECT_TRUE(manager_->BeginQuery(query));
  82     EXPECT_TRUE(manager_->EndQuery(query, submit_count));
  83   }
  84
  85   // Use StrictMock to make 100% sure we know how GL will be called.
  86   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
  87   scoped_ptr<MockGLES2Decoder> decoder_;
  88   scoped_ptr<QueryManager> manager_;
  89
  90  private:
  91   class MockCommandBufferEngine : public CommandBufferEngine {
  92    public:
  93     MockCommandBufferEngine() {
  94       scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
  95       shared_memory->CreateAndMapAnonymous(kSharedBufferSize);
  96       valid_buffer_ =
  97           MakeBufferFromSharedMemory(shared_memory.Pass(), kSharedBufferSize);
  98       data_ = static_cast<uint8*>(valid_buffer_->memory());
  99       ClearSharedMemory();
 100     }
 101
 102     virtual ~MockCommandBufferEngine() {
 103     }
 104
 105     virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id)
 106         OVERRIDE {
 107       return shm_id == kSharedMemoryId ? valid_buffer_ : invalid_buffer_;
 108     }
 109
 110     void ClearSharedMemory() {
 111       memset(data_, kInitialMemoryValue, kSharedBufferSize);
 112     }
 113
 114     virtual void set_token(int32 token) OVERRIDE {
 115       DCHECK(false);
 116     }
 117
 118     virtual bool SetGetBuffer(int32 /* transfer_buffer_id */) OVERRIDE {
 119       DCHECK(false);
 120       return false;
 121     }
 122
 123     // Overridden from CommandBufferEngine.
 124     virtual bool SetGetOffset(int32 offset) OVERRIDE {
 125       DCHECK(false);
 126       return false;
 127     }
 128
 129     // Overridden from CommandBufferEngine.
 130     virtual int32 GetGetOffset() OVERRIDE {
 131       DCHECK(false);
 132       return 0;
 133     }
 134
 135    private:
 136     uint8* data_;
 137     scoped_refptr<gpu::Buffer> valid_buffer_;
 138     scoped_refptr<gpu::Buffer> invalid_buffer_;
 139   };
 140
 141   scoped_ptr<MockCommandBufferEngine> engine_;
 142 };
 143
 144 // GCC requires these declarations, but MSVC requires they not be present
 145 #ifndef COMPILER_MSVC
 146 const int32 QueryManagerTest::kSharedMemoryId;
 147 const size_t QueryManagerTest::kSharedBufferSize;
 148 const uint32 QueryManagerTest::kSharedMemoryOffset;
 149 const int32 QueryManagerTest::kInvalidSharedMemoryId;
 150 const uint32 QueryManagerTest::kInvalidSharedMemoryOffset;
 151 const uint32 QueryManagerTest::kInitialResult;
 152 const uint8 QueryManagerTest::kInitialMemoryValue;
 153 #endif
 154
 155 TEST_F(QueryManagerTest, Basic) {
 156   const GLuint kClient1Id = 1;
 157   const GLuint kService1Id = 11;
 158   const GLuint kClient2Id = 2;
 159
 160   EXPECT_FALSE(manager_->HavePendingQueries());
 161   // Check we can create a Query.
 162   scoped_refptr<QueryManager::Query> query(
 163       CreateQuery(GL_ANY_SAMPLES_PASSED_EXT, kClient1Id,
 164                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
 165   ASSERT_TRUE(query.get() != NULL);
 166   // Check we can get the same Query.
 167   EXPECT_EQ(query.get(), manager_->GetQuery(kClient1Id));
 168   // Check we get nothing for a non-existent query.
 169   EXPECT_TRUE(manager_->GetQuery(kClient2Id) == NULL);
 170   // Check we can delete the query.
 171   manager_->RemoveQuery(kClient1Id);
 172   // Check we get nothing for a non-existent query.
 173   EXPECT_TRUE(manager_->GetQuery(kClient1Id) == NULL);
 174   // Check query is deleted
 175   EXPECT_TRUE(query->IsDeleted());
 176   EXPECT_FALSE(manager_->HavePendingQueries());
 177 }
 178
 179 TEST_F(QueryManagerTest, Destroy) {
 180   const GLuint kClient1Id = 1;
 181   const GLuint kService1Id = 11;
 182
 183   // Create Query.
 184   scoped_refptr<QueryManager::Query> query(
 185       CreateQuery(GL_ANY_SAMPLES_PASSED_EXT, kClient1Id,
 186                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
 187   ASSERT_TRUE(query.get() != NULL);
 188   EXPECT_CALL(*gl_, DeleteQueriesARB(1, ::testing::Pointee(kService1Id)))
 189       .Times(1)
 190       .RetiresOnSaturation();
 191   manager_->Destroy(true);
 192   // Check we get nothing for a non-existent query.
 193   EXPECT_TRUE(manager_->GetQuery(kClient1Id) == NULL);
 194   // Check query is deleted
 195   EXPECT_TRUE(query->IsDeleted());
 196 }
 197
 198 TEST_F(QueryManagerTest, QueryBasic) {
 199   const GLuint kClient1Id = 1;
 200   const GLuint kService1Id = 11;
 201   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 202
 203   // Create Query.
 204   scoped_refptr<QueryManager::Query> query(
 205       CreateQuery(kTarget, kClient1Id,
 206                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
 207   ASSERT_TRUE(query.get() != NULL);
 208
 209   EXPECT_TRUE(query->IsValid());
 210   EXPECT_FALSE(query->IsDeleted());
 211   EXPECT_FALSE(query->pending());
 212   EXPECT_EQ(kTarget, query->target());
 213   EXPECT_EQ(kSharedMemoryId, query->shm_id());
 214   EXPECT_EQ(kSharedMemoryOffset, query->shm_offset());
 215 }
 216
 217 TEST_F(QueryManagerTest, ProcessPendingQuery) {
 218   const GLuint kClient1Id = 1;
 219   const GLuint kService1Id = 11;
 220   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 221   const base::subtle::Atomic32 kSubmitCount = 123;
 222   const GLuint kResult = 1;
 223
 224   // Check nothing happens if there are no pending queries.
 225   EXPECT_TRUE(manager_->ProcessPendingQueries());
 226
 227   // Create Query.
 228   scoped_refptr<QueryManager::Query> query(
 229       CreateQuery(kTarget, kClient1Id,
 230                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
 231   ASSERT_TRUE(query.get() != NULL);
 232
 233   // Setup shared memory like client would.
 234   QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
 235       kSharedMemoryId, kSharedMemoryOffset, sizeof(*sync));
 236   ASSERT_TRUE(sync != NULL);
 237   sync->Reset();
 238
 239   // Queue it
 240   QueueQuery(query.get(), kService1Id, kSubmitCount);
 241   EXPECT_TRUE(query->pending());
 242   EXPECT_TRUE(manager_->HavePendingQueries());
 243
 244   // Process with return not available.
 245   // Expect 1 GL command.
 246   EXPECT_CALL(*gl_,
 247       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 248       .WillOnce(SetArgumentPointee<2>(0))
 249       .RetiresOnSaturation();
 250   EXPECT_TRUE(manager_->ProcessPendingQueries());
 251   EXPECT_TRUE(query->pending());
 252   EXPECT_EQ(0, sync->process_count);
 253   EXPECT_EQ(0u, sync->result);
 254
 255   // Process with return available.
 256   // Expect 2 GL commands.
 257   EXPECT_CALL(*gl_,
 258       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 259       .WillOnce(SetArgumentPointee<2>(1))
 260       .RetiresOnSaturation();
 261   EXPECT_CALL(*gl_,
 262       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_EXT, _))
 263       .WillOnce(SetArgumentPointee<2>(kResult))
 264       .RetiresOnSaturation();
 265   EXPECT_TRUE(manager_->ProcessPendingQueries());
 266   EXPECT_FALSE(query->pending());
 267   EXPECT_EQ(kSubmitCount, sync->process_count);
 268   EXPECT_EQ(kResult, sync->result);
 269   EXPECT_FALSE(manager_->HavePendingQueries());
 270
 271   // Process with no queries.
 272   // Expect no GL commands/
 273   EXPECT_TRUE(manager_->ProcessPendingQueries());
 274 }
 275
 276 TEST_F(QueryManagerTest, ProcessPendingQueries) {
 277   const GLuint kClient1Id = 1;
 278   const GLuint kService1Id = 11;
 279   const GLuint kClient2Id = 2;
 280   const GLuint kService2Id = 12;
 281   const GLuint kClient3Id = 3;
 282   const GLuint kService3Id = 13;
 283   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 284   const base::subtle::Atomic32 kSubmitCount1 = 123;
 285   const base::subtle::Atomic32 kSubmitCount2 = 123;
 286   const base::subtle::Atomic32 kSubmitCount3 = 123;
 287   const GLuint kResult1 = 1;
 288   const GLuint kResult2 = 1;
 289   const GLuint kResult3 = 1;
 290
 291   // Setup shared memory like client would.
 292   QuerySync* sync1 = decoder_->GetSharedMemoryAs<QuerySync*>(
 293       kSharedMemoryId, kSharedMemoryOffset, sizeof(*sync1) * 3);
 294   ASSERT_TRUE(sync1 != NULL);
 295   QuerySync* sync2 = sync1 + 1;
 296   QuerySync* sync3 = sync2 + 1;
 297
 298   // Create Queries.
 299   scoped_refptr<QueryManager::Query> query1(
 300       CreateQuery(kTarget, kClient1Id,
 301                   kSharedMemoryId, kSharedMemoryOffset + sizeof(*sync1) * 0,
 302                   kService1Id));
 303   scoped_refptr<QueryManager::Query> query2(
 304       CreateQuery(kTarget, kClient2Id,
 305                   kSharedMemoryId, kSharedMemoryOffset + sizeof(*sync1) * 1,
 306                   kService2Id));
 307   scoped_refptr<QueryManager::Query> query3(
 308       CreateQuery(kTarget, kClient3Id,
 309                   kSharedMemoryId, kSharedMemoryOffset + sizeof(*sync1) * 2,
 310                   kService3Id));
 311   ASSERT_TRUE(query1.get() != NULL);
 312   ASSERT_TRUE(query2.get() != NULL);
 313   ASSERT_TRUE(query3.get() != NULL);
 314   EXPECT_FALSE(manager_->HavePendingQueries());
 315
 316   sync1->Reset();
 317   sync2->Reset();
 318   sync3->Reset();
 319
 320   // Queue them
 321   QueueQuery(query1.get(), kService1Id, kSubmitCount1);
 322   QueueQuery(query2.get(), kService2Id, kSubmitCount2);
 323   QueueQuery(query3.get(), kService3Id, kSubmitCount3);
 324   EXPECT_TRUE(query1->pending());
 325   EXPECT_TRUE(query2->pending());
 326   EXPECT_TRUE(query3->pending());
 327   EXPECT_TRUE(manager_->HavePendingQueries());
 328
 329   // Process with return available for first 2 queries.
 330   // Expect 4 GL commands.
 331   {
 332     InSequence s;
 333     EXPECT_CALL(*gl_,
 334         GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 335         .WillOnce(SetArgumentPointee<2>(1))
 336         .RetiresOnSaturation();
 337     EXPECT_CALL(*gl_,
 338         GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_EXT, _))
 339         .WillOnce(SetArgumentPointee<2>(kResult1))
 340         .RetiresOnSaturation();
 341     EXPECT_CALL(*gl_,
 342         GetQueryObjectuivARB(kService2Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 343         .WillOnce(SetArgumentPointee<2>(1))
 344         .RetiresOnSaturation();
 345     EXPECT_CALL(*gl_,
 346         GetQueryObjectuivARB(kService2Id, GL_QUERY_RESULT_EXT, _))
 347         .WillOnce(SetArgumentPointee<2>(kResult2))
 348         .RetiresOnSaturation();
 349     EXPECT_CALL(*gl_,
 350         GetQueryObjectuivARB(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 351         .WillOnce(SetArgumentPointee<2>(0))
 352         .RetiresOnSaturation();
 353     EXPECT_TRUE(manager_->ProcessPendingQueries());
 354   }
 355   EXPECT_FALSE(query1->pending());
 356   EXPECT_FALSE(query2->pending());
 357   EXPECT_TRUE(query3->pending());
 358   EXPECT_EQ(kSubmitCount1, sync1->process_count);
 359   EXPECT_EQ(kSubmitCount2, sync2->process_count);
 360   EXPECT_EQ(kResult1, sync1->result);
 361   EXPECT_EQ(kResult2, sync2->result);
 362   EXPECT_EQ(0, sync3->process_count);
 363   EXPECT_EQ(0u, sync3->result);
 364   EXPECT_TRUE(manager_->HavePendingQueries());
 365
 366   // Process with renaming query. No result.
 367   // Expect 1 GL commands.
 368   EXPECT_CALL(*gl_,
 369       GetQueryObjectuivARB(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 370       .WillOnce(SetArgumentPointee<2>(0))
 371       .RetiresOnSaturation();
 372   EXPECT_TRUE(manager_->ProcessPendingQueries());
 373   EXPECT_TRUE(query3->pending());
 374   EXPECT_EQ(0, sync3->process_count);
 375   EXPECT_EQ(0u, sync3->result);
 376   EXPECT_TRUE(manager_->HavePendingQueries());
 377
 378   // Process with renaming query. With result.
 379   // Expect 2 GL commands.
 380   EXPECT_CALL(*gl_,
 381       GetQueryObjectuivARB(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 382       .WillOnce(SetArgumentPointee<2>(1))
 383       .RetiresOnSaturation();
 384   EXPECT_CALL(*gl_,
 385       GetQueryObjectuivARB(kService3Id, GL_QUERY_RESULT_EXT, _))
 386       .WillOnce(SetArgumentPointee<2>(kResult3))
 387       .RetiresOnSaturation();
 388   EXPECT_TRUE(manager_->ProcessPendingQueries());
 389   EXPECT_FALSE(query3->pending());
 390   EXPECT_EQ(kSubmitCount3, sync3->process_count);
 391   EXPECT_EQ(kResult3, sync3->result);
 392   EXPECT_FALSE(manager_->HavePendingQueries());
 393 }
 394
 395 TEST_F(QueryManagerTest, ProcessPendingBadSharedMemoryId) {
 396   const GLuint kClient1Id = 1;
 397   const GLuint kService1Id = 11;
 398   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 399   const base::subtle::Atomic32 kSubmitCount = 123;
 400   const GLuint kResult = 1;
 401
 402   // Create Query.
 403   scoped_refptr<QueryManager::Query> query(
 404       CreateQuery(kTarget, kClient1Id,
 405                   kInvalidSharedMemoryId, kSharedMemoryOffset, kService1Id));
 406   ASSERT_TRUE(query.get() != NULL);
 407
 408   // Queue it
 409   QueueQuery(query.get(), kService1Id, kSubmitCount);
 410
 411   // Process with return available.
 412   // Expect 2 GL commands.
 413   EXPECT_CALL(*gl_,
 414       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 415       .WillOnce(SetArgumentPointee<2>(1))
 416       .RetiresOnSaturation();
 417   EXPECT_CALL(*gl_,
 418       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_EXT, _))
 419       .WillOnce(SetArgumentPointee<2>(kResult))
 420       .RetiresOnSaturation();
 421   EXPECT_FALSE(manager_->ProcessPendingQueries());
 422 }
 423
 424 TEST_F(QueryManagerTest, ProcessPendingBadSharedMemoryOffset) {
 425   const GLuint kClient1Id = 1;
 426   const GLuint kService1Id = 11;
 427   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 428   const base::subtle::Atomic32 kSubmitCount = 123;
 429   const GLuint kResult = 1;
 430
 431   // Create Query.
 432   scoped_refptr<QueryManager::Query> query(
 433       CreateQuery(kTarget, kClient1Id,
 434                   kSharedMemoryId, kInvalidSharedMemoryOffset, kService1Id));
 435   ASSERT_TRUE(query.get() != NULL);
 436
 437   // Queue it
 438   QueueQuery(query.get(), kService1Id, kSubmitCount);
 439
 440   // Process with return available.
 441   // Expect 2 GL commands.
 442   EXPECT_CALL(*gl_,
 443       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 444       .WillOnce(SetArgumentPointee<2>(1))
 445       .RetiresOnSaturation();
 446   EXPECT_CALL(*gl_,
 447       GetQueryObjectuivARB(kService1Id, GL_QUERY_RESULT_EXT, _))
 448       .WillOnce(SetArgumentPointee<2>(kResult))
 449       .RetiresOnSaturation();
 450   EXPECT_FALSE(manager_->ProcessPendingQueries());
 451 }
 452
 453 TEST_F(QueryManagerTest, ExitWithPendingQuery) {
 454   const GLuint kClient1Id = 1;
 455   const GLuint kService1Id = 11;
 456   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 457   const base::subtle::Atomic32 kSubmitCount = 123;
 458
 459   // Create Query.
 460   scoped_refptr<QueryManager::Query> query(
 461       CreateQuery(kTarget, kClient1Id,
 462                   kSharedMemoryId, kSharedMemoryOffset, kService1Id));
 463   ASSERT_TRUE(query.get() != NULL);
 464
 465   // Queue it
 466   QueueQuery(query.get(), kService1Id, kSubmitCount);
 467 }
 468
 469 // Test that when based on ARB_occlusion_query2 we use GL_ANY_SAMPLES_PASSED_ARB
 470 // for GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT
 471 TEST_F(QueryManagerTest, ARBOcclusionQuery2) {
 472   const GLuint kClient1Id = 1;
 473   const GLuint kService1Id = 11;
 474   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT;
 475   const base::subtle::Atomic32 kSubmitCount = 123;
 476
 477   TestHelper::SetupFeatureInfoInitExpectations(
 478       gl_.get(),
 479       "GL_ARB_occlusion_query2");
 480   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
 481   feature_info->Initialize();
 482   scoped_ptr<QueryManager> manager(
 483       new QueryManager(decoder_.get(), feature_info.get()));
 484
 485   EXPECT_CALL(*gl_, GenQueriesARB(1, _))
 486      .WillOnce(SetArgumentPointee<1>(kService1Id))
 487      .RetiresOnSaturation();
 488   QueryManager::Query* query = manager->CreateQuery(
 489       kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
 490   ASSERT_TRUE(query != NULL);
 491
 492   EXPECT_CALL(*gl_, BeginQueryARB(GL_ANY_SAMPLES_PASSED_EXT, kService1Id))
 493       .Times(1)
 494       .RetiresOnSaturation();
 495   EXPECT_CALL(*gl_, EndQueryARB(GL_ANY_SAMPLES_PASSED_EXT))
 496       .Times(1)
 497       .RetiresOnSaturation();
 498   EXPECT_TRUE(manager->BeginQuery(query));
 499   EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
 500   manager->Destroy(false);
 501 }
 502
 503 // Test that when based on ARB_occlusion_query we use GL_SAMPLES_PASSED_ARB
 504 // for GL_ANY_SAMPLES_PASSED_EXT
 505 TEST_F(QueryManagerTest, ARBOcclusionQuery) {
 506   const GLuint kClient1Id = 1;
 507   const GLuint kService1Id = 11;
 508   const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
 509   const base::subtle::Atomic32 kSubmitCount = 123;
 510
 511   TestHelper::SetupFeatureInfoInitExpectations(
 512       gl_.get(),
 513       "GL_ARB_occlusion_query");
 514   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
 515   feature_info->Initialize();
 516   scoped_ptr<QueryManager> manager(
 517       new QueryManager(decoder_.get(), feature_info.get()));
 518
 519   EXPECT_CALL(*gl_, GenQueriesARB(1, _))
 520      .WillOnce(SetArgumentPointee<1>(kService1Id))
 521      .RetiresOnSaturation();
 522   QueryManager::Query* query = manager->CreateQuery(
 523       kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
 524   ASSERT_TRUE(query != NULL);
 525
 526   EXPECT_CALL(*gl_, BeginQueryARB(GL_SAMPLES_PASSED_ARB, kService1Id))
 527       .Times(1)
 528       .RetiresOnSaturation();
 529   EXPECT_CALL(*gl_, EndQueryARB(GL_SAMPLES_PASSED_ARB))
 530       .Times(1)
 531       .RetiresOnSaturation();
 532   EXPECT_TRUE(manager->BeginQuery(query));
 533   EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
 534   manager->Destroy(false);
 535 }
 536
 537 TEST_F(QueryManagerTest, GetErrorQuery) {
 538   const GLuint kClient1Id = 1;
 539   const GLenum kTarget = GL_GET_ERROR_QUERY_CHROMIUM;
 540   const base::subtle::Atomic32 kSubmitCount = 123;
 541
 542   TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), "");
 543   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
 544   feature_info->Initialize();
 545   scoped_ptr<QueryManager> manager(
 546       new QueryManager(decoder_.get(), feature_info.get()));
 547
 548   QueryManager::Query* query = manager->CreateQuery(
 549       kTarget, kClient1Id, kSharedMemoryId, kSharedMemoryOffset);
 550   ASSERT_TRUE(query != NULL);
 551
 552   // Setup shared memory like client would.
 553   QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
 554       kSharedMemoryId, kSharedMemoryOffset, sizeof(*sync));
 555   ASSERT_TRUE(sync != NULL);
 556   sync->Reset();
 557
 558   EXPECT_TRUE(manager->BeginQuery(query));
 559
 560   MockErrorState mock_error_state;
 561   EXPECT_CALL(*decoder_.get(), GetErrorState())
 562       .WillRepeatedly(Return(&mock_error_state));
 563   EXPECT_CALL(mock_error_state, GetGLError())
 564       .WillOnce(Return(GL_INVALID_ENUM))
 565       .RetiresOnSaturation();
 566
 567   EXPECT_TRUE(manager->EndQuery(query, kSubmitCount));
 568   EXPECT_FALSE(query->pending());
 569
 570   EXPECT_EQ(static_cast<GLuint>(GL_INVALID_ENUM), sync->result);
 571
 572   manager->Destroy(false);
 573 }
 574
 575 }  // namespace gles2
 576 }  // namespace gpu
 577
 578