// 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 <stddef.h>
#include <stdint.h>

#include <memory>

#include "gpu/command_buffer/client/client_test_helper.h"
#include "gpu/command_buffer/common/gles2_cmd_format.h"
#include "gpu/command_buffer/service/error_state_mock.h"
#include "gpu/command_buffer/service/feature_info.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/gpu_service_test.h"
#include "gpu/command_buffer/service/gpu_tracer.h"
#include "gpu/command_buffer/service/query_manager.h"
#include "gpu/command_buffer/service/test_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_mock.h"
#include "ui/gl/gpu_timing.h"
#include "ui/gl/gpu_timing_fake.h"

using ::testing::_;
using ::testing::InSequence;
using ::testing::Return;
using ::testing::SetArgPointee;

namespace gpu {
namespace gles2 {

class QueryManagerTest : public GpuServiceTest {
 public:
  static const uint32_t kSharedMemoryOffset = 132;
  static const uint32_t kSharedMemory2Offset = 232;
  static const size_t kSharedBufferSize = 2048;
  static const int32_t kInvalidSharedMemoryId = -1;
  static const uint32_t kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
  static const uint32_t kInitialResult = 0xBDBDBDBDu;
  static const uint8_t kInitialMemoryValue = 0xBDu;

  QueryManagerTest() = default;
  ~QueryManagerTest() override = default;

 protected:
  void SetUp() override {
    GpuServiceTest::SetUpWithGLVersion("3.2",
                                       "GL_ARB_occlusion_query, "
                                       "GL_ARB_timer_query");
    SetUpMockGL("GL_EXT_occlusion_query_boolean, GL_ARB_timer_query");
  }

  void TearDown() override {
    decoder_.reset();
    manager_->Destroy(false);
    manager_.reset();
    command_buffer_service_.reset();
    GpuServiceTest::TearDown();
  }

  void SetUpMockGL(const char* extension_expectations) {
    command_buffer_service_.reset(new FakeCommandBufferServiceBase());
    scoped_refptr<gpu::Buffer> buffer =
        command_buffer_service_->CreateTransferBufferHelper(kSharedBufferSize,
                                                            &shared_memory_id_);
    memset(buffer->memory(), kInitialMemoryValue, kSharedBufferSize);
    buffer = command_buffer_service_->CreateTransferBufferHelper(
        kSharedBufferSize, &shared_memory2_id_);
    memset(buffer->memory(), kInitialMemoryValue, kSharedBufferSize);
    decoder_.reset(
        new MockGLES2Decoder(command_buffer_service_.get(), &outputter_));
    TestHelper::SetupFeatureInfoInitExpectations(
        gl_.get(), extension_expectations);
    EXPECT_CALL(*decoder_.get(), GetGLContext())
      .WillRepeatedly(Return(GetGLContext()));
    scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
    feature_info->InitializeForTesting();
    manager_.reset(new QueryManager(decoder_.get(), feature_info.get()));
  }

  QueryManager::Query* CreateQuery(GLenum target,
                                   GLuint client_id,
                                   int32_t shm_id,
                                   uint32_t shm_offset,
                                   GLuint service_id) {
    return CreateQueryOnManager(manager_.get(), target, client_id, shm_id,
                                shm_offset, service_id);
  }

  QueryManager::Query* CreateQueryOnManager(QueryManager* manager,
                                            GLenum target,
                                            GLuint client_id,
                                            int32_t shm_id,
                                            uint32_t shm_offset,
                                            GLuint service_id) {
    if (service_id) {
      EXPECT_CALL(*gl_, GenQueries(1, _))
          .WillOnce(SetArgPointee<1>(service_id))
          .RetiresOnSaturation();
    }
    scoped_refptr<gpu::Buffer> buffer = decoder_->GetSharedMemoryBuffer(shm_id);
    if (!buffer)
      return nullptr;
    QuerySync* sync = static_cast<QuerySync*>(
        buffer->GetDataAddress(shm_offset, sizeof(QuerySync)));
    if (!sync)
      return nullptr;
    return manager->CreateQuery(target, client_id, std::move(buffer), sync);
  }

  void QueueQuery(QueryManager::Query* query,
                  GLuint service_id,
                  base::subtle::Atomic32 submit_count) {
    EXPECT_CALL(*gl_, BeginQuery(query->target(), service_id))
        .Times(1)
        .RetiresOnSaturation();
    EXPECT_CALL(*gl_, EndQuery(query->target()))
        .Times(1)
        .RetiresOnSaturation();
    manager_->BeginQuery(query);
    manager_->EndQuery(query, submit_count);
  }

  TraceOutputter outputter_;
  std::unique_ptr<FakeCommandBufferServiceBase> command_buffer_service_;
  std::unique_ptr<MockGLES2Decoder> decoder_;
  std::unique_ptr<QueryManager> manager_;

  int32_t shared_memory_id_ = 0;
  int32_t shared_memory2_id_ = 0;
};

class QueryManagerManualSetupTest : public QueryManagerTest {
 protected:
  void SetUp() override {
    // Let test setup manually.
  }
};

// GCC requires these declarations, but MSVC requires they not be present
#ifndef COMPILER_MSVC
const uint32_t QueryManagerTest::kSharedMemoryOffset;
const uint32_t QueryManagerTest::kSharedMemory2Offset;
const size_t QueryManagerTest::kSharedBufferSize;
const int32_t QueryManagerTest::kInvalidSharedMemoryId;
const uint32_t QueryManagerTest::kInvalidSharedMemoryOffset;
const uint32_t QueryManagerTest::kInitialResult;
const uint8_t QueryManagerTest::kInitialMemoryValue;
#endif

TEST_F(QueryManagerTest, Basic) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLuint kClient2Id = 2;

  EXPECT_FALSE(manager_->HavePendingQueries());
  // Check we can create a Query.
  scoped_refptr<QueryManager::Query> query(
      CreateQuery(GL_ANY_SAMPLES_PASSED_EXT, kClient1Id, shared_memory_id_,
                  kSharedMemoryOffset, kService1Id));
  ASSERT_TRUE(query.get() != NULL);
  // Check we can get the same Query.
  EXPECT_EQ(query.get(), manager_->GetQuery(kClient1Id));
  // Check we get nothing for a non-existent query.
  EXPECT_TRUE(manager_->GetQuery(kClient2Id) == NULL);
  // Check we can delete the query.
  EXPECT_CALL(*gl_, DeleteQueries(1, ::testing::Pointee(kService1Id)))
      .Times(1)
      .RetiresOnSaturation();
  manager_->RemoveQuery(kClient1Id);
  // Check we get nothing for a non-existent query.
  EXPECT_TRUE(manager_->GetQuery(kClient1Id) == NULL);
  // Check query is deleted
  EXPECT_TRUE(query->IsDeleted());
  EXPECT_FALSE(manager_->HavePendingQueries());
}

TEST_F(QueryManagerTest, Destroy) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;

  // Create Query.
  scoped_refptr<QueryManager::Query> query(
      CreateQuery(GL_ANY_SAMPLES_PASSED_EXT, kClient1Id, shared_memory_id_,
                  kSharedMemoryOffset, kService1Id));
  ASSERT_TRUE(query.get() != NULL);
  EXPECT_CALL(*gl_, DeleteQueries(1, ::testing::Pointee(kService1Id)))
      .Times(1)
      .RetiresOnSaturation();
  manager_->Destroy(true);
  // Check we get nothing for a non-existent query.
  EXPECT_TRUE(manager_->GetQuery(kClient1Id) == NULL);
  // Check query is deleted
  EXPECT_TRUE(query->IsDeleted());
}

TEST_F(QueryManagerTest, QueryBasic) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;

  // Create Query.
  scoped_refptr<QueryManager::Query> query(
      CreateQuery(kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset,
                  kService1Id));
  ASSERT_TRUE(query.get() != NULL);

  EXPECT_TRUE(query->IsValid());
  EXPECT_FALSE(query->IsDeleted());
  EXPECT_FALSE(query->IsPending());
  EXPECT_EQ(kTarget, query->target());
}

TEST_F(QueryManagerTest, ProcessPendingQuery) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;
  const GLuint kResult = 1;

  // Check nothing happens if there are no pending queries.
  manager_->ProcessPendingQueries(false);

  // Create Query.
  scoped_refptr<QueryManager::Query> query(
      CreateQuery(kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset,
                  kService1Id));
  ASSERT_TRUE(query.get() != NULL);

  // Setup shared memory like client would.
  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  ASSERT_TRUE(sync != NULL);
  sync->Reset();

  // Queue it
  QueueQuery(query.get(), kService1Id, kSubmitCount);
  EXPECT_TRUE(query->IsPending());
  EXPECT_TRUE(manager_->HavePendingQueries());

  // Process with return not available.
  // Expect 1 GL command.
  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(0))
      .RetiresOnSaturation();
  manager_->ProcessPendingQueries(false);
  EXPECT_TRUE(query->IsPending());
  EXPECT_EQ(0, sync->process_count);
  EXPECT_EQ(0u, sync->result);

  // Process with return available.
  // Expect 2 GL commands.
  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(1))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_EXT, _))
      .WillOnce(SetArgPointee<2>(kResult))
      .RetiresOnSaturation();
  manager_->ProcessPendingQueries(false);
  EXPECT_FALSE(query->IsPending());
  EXPECT_EQ(kSubmitCount, sync->process_count);
  EXPECT_EQ(kResult, sync->result);
  EXPECT_FALSE(manager_->HavePendingQueries());

  // Process with no queries.
  // Expect no GL commands/
  manager_->ProcessPendingQueries(false);
}

TEST_F(QueryManagerTest, ProcessPendingQueries) {
  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 base::subtle::Atomic32 kSubmitCount1 = 123;
  const base::subtle::Atomic32 kSubmitCount2 = 123;
  const base::subtle::Atomic32 kSubmitCount3 = 123;
  const GLuint kResult1 = 1;
  const GLuint kResult2 = 1;
  const GLuint kResult3 = 1;

  // Setup shared memory like client would.
  QuerySync* sync1 = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync1) * 3);
  ASSERT_TRUE(sync1 != NULL);
  QuerySync* sync2 = sync1 + 1;
  QuerySync* sync3 = sync2 + 1;

  // Create Queries.
  scoped_refptr<QueryManager::Query> query1(
      CreateQuery(kTarget, kClient1Id, shared_memory_id_,
                  kSharedMemoryOffset + sizeof(*sync1) * 0, kService1Id));
  scoped_refptr<QueryManager::Query> query2(
      CreateQuery(kTarget, kClient2Id, shared_memory_id_,
                  kSharedMemoryOffset + sizeof(*sync1) * 1, kService2Id));
  scoped_refptr<QueryManager::Query> query3(
      CreateQuery(kTarget, kClient3Id, shared_memory_id_,
                  kSharedMemoryOffset + sizeof(*sync1) * 2, kService3Id));
  ASSERT_TRUE(query1.get() != NULL);
  ASSERT_TRUE(query2.get() != NULL);
  ASSERT_TRUE(query3.get() != NULL);
  EXPECT_FALSE(manager_->HavePendingQueries());

  sync1->Reset();
  sync2->Reset();
  sync3->Reset();

  // Queue them
  QueueQuery(query1.get(), kService1Id, kSubmitCount1);
  QueueQuery(query2.get(), kService2Id, kSubmitCount2);
  QueueQuery(query3.get(), kService3Id, kSubmitCount3);
  EXPECT_TRUE(query1->IsPending());
  EXPECT_TRUE(query2->IsPending());
  EXPECT_TRUE(query3->IsPending());
  EXPECT_TRUE(manager_->HavePendingQueries());

  // Process with return available for first 2 queries.
  // Expect 4 GL commands.
  {
    InSequence s;
    EXPECT_CALL(
        *gl_, GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
        .WillOnce(SetArgPointee<2>(1))
        .RetiresOnSaturation();
    EXPECT_CALL(*gl_, GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_EXT, _))
        .WillOnce(SetArgPointee<2>(kResult1))
        .RetiresOnSaturation();
    EXPECT_CALL(
        *gl_, GetQueryObjectuiv(kService2Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
        .WillOnce(SetArgPointee<2>(1))
        .RetiresOnSaturation();
    EXPECT_CALL(*gl_, GetQueryObjectuiv(kService2Id, GL_QUERY_RESULT_EXT, _))
        .WillOnce(SetArgPointee<2>(kResult2))
        .RetiresOnSaturation();
    EXPECT_CALL(
        *gl_, GetQueryObjectuiv(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
        .WillOnce(SetArgPointee<2>(0))
        .RetiresOnSaturation();
    manager_->ProcessPendingQueries(false);
  }
  EXPECT_FALSE(query1->IsPending());
  EXPECT_FALSE(query2->IsPending());
  EXPECT_TRUE(query3->IsPending());
  EXPECT_EQ(kSubmitCount1, sync1->process_count);
  EXPECT_EQ(kSubmitCount2, sync2->process_count);
  EXPECT_EQ(kResult1, sync1->result);
  EXPECT_EQ(kResult2, sync2->result);
  EXPECT_EQ(0, sync3->process_count);
  EXPECT_EQ(0u, sync3->result);
  EXPECT_TRUE(manager_->HavePendingQueries());

  // Process with renaming query. No result.
  // Expect 1 GL commands.
  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(0))
      .RetiresOnSaturation();
  manager_->ProcessPendingQueries(false);
  EXPECT_TRUE(query3->IsPending());
  EXPECT_EQ(0, sync3->process_count);
  EXPECT_EQ(0u, sync3->result);
  EXPECT_TRUE(manager_->HavePendingQueries());

  // Process with renaming query. With result.
  // Expect 2 GL commands.
  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService3Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(1))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, GetQueryObjectuiv(kService3Id, GL_QUERY_RESULT_EXT, _))
      .WillOnce(SetArgPointee<2>(kResult3))
      .RetiresOnSaturation();
  manager_->ProcessPendingQueries(false);
  EXPECT_FALSE(query3->IsPending());
  EXPECT_EQ(kSubmitCount3, sync3->process_count);
  EXPECT_EQ(kResult3, sync3->result);
  EXPECT_FALSE(manager_->HavePendingQueries());
}

TEST_F(QueryManagerTest, ExitWithPendingQuery) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;

  // Create Query.
  scoped_refptr<QueryManager::Query> query(
      CreateQuery(kTarget, kClient1Id, shared_memory_id_, 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 base::subtle::Atomic32 kSubmitCount = 123;

  TestHelper::SetupFeatureInfoInitExpectations(
      gl_.get(),
      "GL_ARB_occlusion_query2");
  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  feature_info->InitializeForTesting();
  std::unique_ptr<QueryManager> manager(
      new QueryManager(decoder_.get(), feature_info.get()));

  QueryManager::Query* query =
      CreateQueryOnManager(manager.get(), kTarget, kClient1Id,
                           shared_memory_id_, kSharedMemoryOffset, kService1Id);
  ASSERT_TRUE(query != NULL);

  EXPECT_CALL(*gl_, BeginQuery(GL_ANY_SAMPLES_PASSED_EXT, kService1Id))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, EndQuery(GL_ANY_SAMPLES_PASSED_EXT))
      .Times(1)
      .RetiresOnSaturation();
  manager->BeginQuery(query);
  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 base::subtle::Atomic32 kSubmitCount = 123;

  TestHelper::SetupFeatureInfoInitExpectations(
      gl_.get(),
      "GL_ARB_occlusion_query");
  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  feature_info->InitializeForTesting();
  std::unique_ptr<QueryManager> manager(
      new QueryManager(decoder_.get(), feature_info.get()));

  QueryManager::Query* query =
      CreateQueryOnManager(manager.get(), kTarget, kClient1Id,
                           shared_memory_id_, kSharedMemoryOffset, kService1Id);
  ASSERT_TRUE(query != NULL);

  EXPECT_CALL(*gl_, BeginQuery(GL_SAMPLES_PASSED_ARB, kService1Id))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, EndQuery(GL_SAMPLES_PASSED_ARB))
      .Times(1)
      .RetiresOnSaturation();
  manager->BeginQuery(query);
  manager->EndQuery(query, kSubmitCount);
  manager->Destroy(false);
}

TEST_F(QueryManagerTest, ARBOcclusionPauseResume) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLuint kService2Id = 12;
  const GLenum kTarget = GL_ANY_SAMPLES_PASSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;

  TestHelper::SetupFeatureInfoInitExpectations(
      gl_.get(),
      "GL_ARB_occlusion_query");
  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  feature_info->InitializeForTesting();
  std::unique_ptr<QueryManager> manager(
      new QueryManager(decoder_.get(), feature_info.get()));

  QueryManager::Query* query =
      CreateQueryOnManager(manager.get(), kTarget, kClient1Id,
                           shared_memory_id_, kSharedMemoryOffset, kService1Id);
  ASSERT_TRUE(query != NULL);

  EXPECT_CALL(*gl_, BeginQuery(GL_SAMPLES_PASSED_ARB, kService1Id))
      .Times(1)
      .RetiresOnSaturation();
  manager->BeginQuery(query);

  // Pause and Resume the manager.
  EXPECT_CALL(*gl_, EndQuery(GL_SAMPLES_PASSED_ARB))
      .Times(1)
      .RetiresOnSaturation();
  manager->PauseQueries();

  EXPECT_CALL(*gl_, GenQueries(1, _))
      .WillOnce(SetArgPointee<1>(kService2Id))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, BeginQuery(GL_SAMPLES_PASSED_ARB, kService2Id))
      .Times(1)
      .RetiresOnSaturation();
  manager->ResumeQueries();

  EXPECT_CALL(*gl_, EndQuery(GL_SAMPLES_PASSED_ARB))
      .Times(1)
      .RetiresOnSaturation();
  manager->EndQuery(query, kSubmitCount);

  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService2Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(1u))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_EXT, _))
      .WillOnce(SetArgPointee<2>(0u))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, GetQueryObjectuiv(kService2Id, GL_QUERY_RESULT_EXT, _))
      .WillOnce(SetArgPointee<2>(1u))
      .RetiresOnSaturation();
  manager->ProcessPendingQueries(false);
  EXPECT_TRUE(query->IsFinished());

  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  EXPECT_EQ(1u, sync->result);

  // Make sure new query still works.
  EXPECT_CALL(*gl_, DeleteQueries(1, ::testing::Pointee(kService2Id)))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, BeginQuery(GL_SAMPLES_PASSED_ARB, kService1Id))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, EndQuery(GL_SAMPLES_PASSED_ARB))
      .Times(1)
      .RetiresOnSaturation();
  manager->BeginQuery(query);
  manager->EndQuery(query, kSubmitCount + 1);

  EXPECT_CALL(*gl_,
              GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
      .WillOnce(SetArgPointee<2>(1u))
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, GetQueryObjectuiv(kService1Id, GL_QUERY_RESULT_EXT, _))
      .WillOnce(SetArgPointee<2>(0u))
      .RetiresOnSaturation();
  manager->ProcessPendingQueries(false);
  EXPECT_TRUE(query->IsFinished());

  EXPECT_EQ(0u, sync->result);
  EXPECT_CALL(*gl_, DeleteQueries(1, ::testing::Pointee(kService1Id)))
      .Times(1)
      .RetiresOnSaturation();
  manager->Destroy(true);
}

TEST_F(QueryManagerTest, TimeElapsedQuery) {
  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIME_ELAPSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;
  gl::GPUTimingFake fake_timing_queries;
  decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  fake_timing_queries.ExpectGPUTimerQuery(*gl_, true);
  fake_timing_queries.SetCurrentGLTime(
      200 * base::Time::kNanosecondsPerMicrosecond);
  manager_->BeginQuery(query);
  fake_timing_queries.SetCurrentGLTime(
      300 * base::Time::kNanosecondsPerMicrosecond);
  manager_->EndQuery(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());

  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  const uint64_t expected_result =
      100u * base::Time::kNanosecondsPerMicrosecond;
  EXPECT_EQ(expected_result, sync->result);

  manager_->Destroy(false);
}

TEST_F(QueryManagerTest, TimeElapsedPauseResume) {
  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIME_ELAPSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;
  gl::GPUTimingFake fake_timing_queries;
  decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  fake_timing_queries.ExpectGPUTimerQuery(*gl_, true);
  fake_timing_queries.SetCurrentGLTime(
      200 * base::Time::kNanosecondsPerMicrosecond);
  manager_->BeginQuery(query);

  // Pause and Resume here.
  fake_timing_queries.SetCurrentGLTime(
      300 * base::Time::kNanosecondsPerMicrosecond);
  manager_->PauseQueries();

  fake_timing_queries.SetCurrentGLTime(
      400 * base::Time::kNanosecondsPerMicrosecond);
  manager_->ResumeQueries();

  fake_timing_queries.SetCurrentGLTime(
      500 * base::Time::kNanosecondsPerMicrosecond);
  manager_->EndQuery(query, kSubmitCount);

  manager_->ProcessPendingQueries(false);
  EXPECT_TRUE(query->IsFinished());

  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  const uint64_t expected_result =
      300u * base::Time::kNanosecondsPerMicrosecond;
  EXPECT_EQ(expected_result, sync->result);

  // Make sure next query works properly.
  fake_timing_queries.SetCurrentGLTime(
      600 * base::Time::kNanosecondsPerMicrosecond);
  manager_->BeginQuery(query);
  fake_timing_queries.SetCurrentGLTime(
      700 * base::Time::kNanosecondsPerMicrosecond);
  manager_->EndQuery(query, kSubmitCount + 1);
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());

  const uint64_t expected_result2 =
      100u * base::Time::kNanosecondsPerMicrosecond;
  EXPECT_EQ(expected_result2, sync->result);

  manager_->Destroy(false);
}

TEST_F(QueryManagerManualSetupTest, TimeElapsedDisjoint) {
  GpuServiceTest::SetUpWithGLVersion("OpenGL ES 3.0",
                                     "GL_EXT_disjoint_timer_query");
  gl::GPUTimingFake fake_timing_queries;
  fake_timing_queries.ExpectDisjointCalls(*gl_);
  SetUpMockGL("GL_EXT_disjoint_timer_query");

  DisjointValueSync* disjoint_sync =
      decoder_->GetSharedMemoryAs<DisjointValueSync*>(
          shared_memory2_id_, kSharedMemory2Offset, sizeof(*disjoint_sync));
  manager_->SetDisjointSync(shared_memory2_id_, kSharedMemory2Offset);

  const uint32_t current_disjoint_value = disjoint_sync->GetDisjointCount();
  ASSERT_EQ(0u, current_disjoint_value);

  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIME_ELAPSED_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  // Disjoint happening before the query should not trigger a disjoint event.
  fake_timing_queries.SetDisjoint();

  fake_timing_queries.ExpectGPUTimerQuery(*gl_, true);
  manager_->BeginQuery(query);
  manager_->EndQuery(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());
  EXPECT_EQ(current_disjoint_value, disjoint_sync->GetDisjointCount());

  // Disjoint happening during query should trigger disjoint event.
  fake_timing_queries.ExpectGPUTimerQuery(*gl_, true);
  manager_->BeginQuery(query);
  fake_timing_queries.SetDisjoint();
  manager_->EndQuery(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());
  EXPECT_NE(current_disjoint_value, disjoint_sync->GetDisjointCount());

  manager_->Destroy(false);
}

TEST_F(QueryManagerTest, TimeStampQuery) {
  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIMESTAMP_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;
  gl::GPUTimingFake fake_timing_queries;

  decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  const uint64_t expected_result =
      100u * base::Time::kNanosecondsPerMicrosecond;
  fake_timing_queries.SetCurrentGLTime(expected_result);
  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  EXPECT_EQ(expected_result, sync->result);

  manager_->Destroy(false);
}

TEST_F(QueryManagerTest, TimeStampQueryPending) {
  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIMESTAMP_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;
  gl::GPUTimingFake fake_timing_queries;

  decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  const uint64_t expected_result =
      100u * base::Time::kNanosecondsPerMicrosecond;
  fake_timing_queries.SetCurrentGLTime(expected_result);
  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  EXPECT_TRUE(query->IsPending());
  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  EXPECT_EQ(expected_result, sync->result);

  manager_->Destroy(false);
}

TEST_F(QueryManagerManualSetupTest, TimeStampDisjoint) {
  GpuServiceTest::SetUpWithGLVersion("OpenGL ES 3.0",
                                     "GL_EXT_disjoint_timer_query");
  gl::GPUTimingFake fake_timing_queries;
  fake_timing_queries.ExpectDisjointCalls(*gl_);
  SetUpMockGL("GL_EXT_disjoint_timer_query");

  DisjointValueSync* disjoint_sync =
      decoder_->GetSharedMemoryAs<DisjointValueSync*>(
          shared_memory2_id_, kSharedMemory2Offset, sizeof(*disjoint_sync));
  manager_->SetDisjointSync(shared_memory2_id_, kSharedMemory2Offset);

  const uint32_t current_disjoint_value = disjoint_sync->GetDisjointCount();
  ASSERT_EQ(0u, current_disjoint_value);

  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIMESTAMP_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  // Disjoint happening before the query should not trigger a disjoint event.
  fake_timing_queries.SetDisjoint();

  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());
  EXPECT_EQ(current_disjoint_value, disjoint_sync->GetDisjointCount());

  // Disjoint happening during query should trigger disjoint event.
  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  fake_timing_queries.SetDisjoint();
  manager_->ProcessPendingQueries(false);

  EXPECT_TRUE(query->IsFinished());
  EXPECT_NE(current_disjoint_value, disjoint_sync->GetDisjointCount());

  manager_->Destroy(false);
}

TEST_F(QueryManagerManualSetupTest, DisjointContinualTest) {
  GpuServiceTest::SetUpWithGLVersion("OpenGL ES 3.0",
                                     "GL_EXT_disjoint_timer_query");
  gl::GPUTimingFake fake_timing_queries;
  fake_timing_queries.ExpectDisjointCalls(*gl_);
  SetUpMockGL("GL_EXT_disjoint_timer_query");

  DisjointValueSync* disjoint_sync =
      decoder_->GetSharedMemoryAs<DisjointValueSync*>(
          shared_memory2_id_, kSharedMemory2Offset, sizeof(*disjoint_sync));
  manager_->SetDisjointSync(shared_memory2_id_, kSharedMemory2Offset);

  const uint32_t current_disjoint_value = disjoint_sync->GetDisjointCount();
  ASSERT_EQ(0u, current_disjoint_value);

  // Disjoint value should not be updated until we have a timestamp query.
  fake_timing_queries.SetDisjoint();
  manager_->ProcessFrameBeginUpdates();
  EXPECT_EQ(current_disjoint_value, disjoint_sync->GetDisjointCount());

  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_TIMESTAMP_EXT;
  const base::subtle::Atomic32 kSubmitCount = 123;

  QueryManager::Query* query = CreateQuery(
      kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  fake_timing_queries.ExpectGPUTimeStampQuery(*gl_, false);
  manager_->QueryCounter(query, kSubmitCount);
  manager_->ProcessPendingQueries(false);

  EXPECT_EQ(current_disjoint_value, disjoint_sync->GetDisjointCount());
  fake_timing_queries.SetDisjoint();
  manager_->ProcessFrameBeginUpdates();
  EXPECT_NE(current_disjoint_value, disjoint_sync->GetDisjointCount());

  manager_->Destroy(false);
}

TEST_F(QueryManagerTest, GetErrorQuery) {
  const GLuint kClient1Id = 1;
  const GLenum kTarget = GL_GET_ERROR_QUERY_CHROMIUM;
  const base::subtle::Atomic32 kSubmitCount = 123;

  TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), "");
  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  feature_info->InitializeForTesting();
  std::unique_ptr<QueryManager> manager(
      new QueryManager(decoder_.get(), feature_info.get()));

  QueryManager::Query* query =
      CreateQueryOnManager(manager.get(), kTarget, kClient1Id,
                           shared_memory_id_, kSharedMemoryOffset, 0);
  ASSERT_TRUE(query != NULL);

  // Setup shared memory like client would.
  QuerySync* sync = decoder_->GetSharedMemoryAs<QuerySync*>(
      shared_memory_id_, kSharedMemoryOffset, sizeof(*sync));
  ASSERT_TRUE(sync != NULL);
  sync->Reset();

  manager->BeginQuery(query);

  MockErrorState mock_error_state;
  EXPECT_CALL(*decoder_.get(), GetErrorState())
      .WillRepeatedly(Return(&mock_error_state));
  EXPECT_CALL(mock_error_state, GetGLError())
      .WillOnce(Return(GL_INVALID_ENUM))
      .RetiresOnSaturation();

  manager->EndQuery(query, kSubmitCount);
  EXPECT_FALSE(query->IsPending());

  EXPECT_EQ(static_cast<GLuint>(GL_INVALID_ENUM), sync->result);

  manager->Destroy(false);
}

TEST_F(QueryManagerTest, OcclusionQuery) {
  const GLuint kClient1Id = 1;
  const GLuint kService1Id = 11;
  const GLenum kTarget = GL_SAMPLES_PASSED_ARB;
  const base::subtle::Atomic32 kSubmitCount = 123;

  TestHelper::SetupFeatureInfoInitExpectations(
      gl_.get(),
      "GL_ARB_occlusion_query");
  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
  feature_info->InitializeForTesting();
  std::unique_ptr<QueryManager> manager(
      new QueryManager(decoder_.get(), feature_info.get()));

  QueryManager::Query* query =
      CreateQueryOnManager(manager.get(), kTarget, kClient1Id,
                           shared_memory_id_, kSharedMemoryOffset, kService1Id);
  ASSERT_TRUE(query != NULL);

  EXPECT_CALL(*gl_, BeginQuery(GL_SAMPLES_PASSED_ARB, kService1Id))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(*gl_, EndQuery(GL_SAMPLES_PASSED_ARB))
      .Times(1)
      .RetiresOnSaturation();
  manager->BeginQuery(query);
  manager->EndQuery(query, kSubmitCount);
  manager->Destroy(false);
}

}  // namespace gles2
}  // namespace gpu