gpu/command_buffer/service/shader_manager_unittest.cc - chromium/src - Git at Google

 // 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/shader_manager.h"

 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"

 using ::testing::Return;
 using ::testing::ReturnRef;

 namespace gpu {
 namespace gles2 {

 class ShaderManagerTest : public GpuServiceTest {
  public:
   ShaderManagerTest() : manager_(nullptr) {}

   ~ShaderManagerTest() override { manager_.Destroy(false); }

  protected:
   ShaderManager manager_;
 };

 TEST_F(ShaderManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kShader1Type = GL_VERTEX_SHADER;
   const GLuint kClient2Id = 2;
   // Check we can create shader.
   Shader* info0 = manager_.CreateShader(
       kClient1Id, kService1Id, kShader1Type);
   // Check shader got created.
   ASSERT_TRUE(info0 != nullptr);
   Shader* shader1 = manager_.GetShader(kClient1Id);
   ASSERT_EQ(info0, shader1);
   // Check we get nothing for a non-existent shader.
   EXPECT_TRUE(manager_.GetShader(kClient2Id) == nullptr);
   // Check we can't get the shader after we remove it.
   EXPECT_CALL(*gl_, DeleteShader(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Delete(shader1);
   EXPECT_TRUE(manager_.GetShader(kClient1Id) == nullptr);
 }

 TEST_F(ShaderManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kShader1Type = GL_VERTEX_SHADER;
   // Check we can create shader.
   Shader* shader1 = manager_.CreateShader(
       kClient1Id, kService1Id, kShader1Type);
   // Check shader got created.
   ASSERT_TRUE(shader1 != nullptr);
   EXPECT_CALL(*gl_, DeleteShader(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Destroy(true);
   // Check that resources got freed.
   shader1 = manager_.GetShader(kClient1Id);
   ASSERT_TRUE(shader1 == nullptr);
 }

 TEST_F(ShaderManagerTest, DeleteBug) {
   const GLuint kClient1Id = 1;
   const GLuint kClient2Id = 2;
   const GLuint kService1Id = 11;
   const GLuint kService2Id = 12;
   const GLenum kShaderType = GL_VERTEX_SHADER;
   // Check we can create shader.
   scoped_refptr<Shader> shader1(
       manager_.CreateShader(kClient1Id, kService1Id, kShaderType));
   scoped_refptr<Shader> shader2(
       manager_.CreateShader(kClient2Id, kService2Id, kShaderType));
   ASSERT_TRUE(shader1.get());
   ASSERT_TRUE(shader2.get());
   manager_.UseShader(shader1.get());
   manager_.Delete(shader1.get());

   EXPECT_CALL(*gl_, DeleteShader(kService2Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Delete(shader2.get());
   EXPECT_TRUE(manager_.IsOwned(shader1.get()));
   EXPECT_FALSE(manager_.IsOwned(shader2.get()));

   EXPECT_CALL(*gl_, DeleteShader(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.UnuseShader(shader1.get());
 }

 TEST_F(ShaderManagerTest, DoCompile) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kShader1Type = GL_VERTEX_SHADER;
   const char* kClient1Source = "hello world";
   const GLenum kAttrib1Type = GL_FLOAT_VEC2;
   const GLint kAttrib1Size = 2;
   const GLenum kAttrib1Precision = GL_MEDIUM_FLOAT;
   const char* kAttrib1Name = "attr1";
   const GLenum kAttrib2Type = GL_FLOAT_VEC3;
   const GLint kAttrib2Size = 4;
   const GLenum kAttrib2Precision = GL_HIGH_FLOAT;
   const char* kAttrib2Name = "attr2";
   const bool kAttribStaticUse = false;
   const GLenum kUniform1Type = GL_FLOAT_MAT2;
   const GLint kUniform1Size = 3;
   const GLenum kUniform1Precision = GL_LOW_FLOAT;
   const bool kUniform1StaticUse = true;
   const char* kUniform1Name = "uni1";
   const GLenum kUniform2Type = GL_FLOAT_MAT3;
   const GLint kUniform2Size = 5;
   const GLenum kUniform2Precision = GL_MEDIUM_FLOAT;
   const bool kUniform2StaticUse = false;
   const char* kUniform2Name = "uni2";
   const GLenum kVarying1Type = GL_FLOAT_VEC4;
   const GLint kVarying1Size = 1;
   const GLenum kVarying1Precision = GL_HIGH_FLOAT;
   const bool kVarying1StaticUse = false;
   const char* kVarying1Name = "varying1";
   const GLenum kOutputVariable1Type = GL_FLOAT_VEC4;
   const GLint kOutputVariable1Size = 4;
   const GLenum kOutputVariable1Precision = GL_MEDIUM_FLOAT;
   const char* kOutputVariable1Name = "gl_FragColor";
   const bool kOutputVariable1StaticUse = true;

   const GLint kInterfaceBlock1Size = 1;
   const sh::BlockLayoutType kInterfaceBlock1Layout = sh::BLOCKLAYOUT_STANDARD;
   const bool kInterfaceBlock1RowMajor = false;
   const bool kInterfaceBlock1StaticUse = false;
   const char* kInterfaceBlock1Name = "block1";
   const char* kInterfaceBlock1InstanceName = "block1instance";
   const GLenum kInterfaceBlock1Field1Type = GL_FLOAT_VEC4;
   const GLint kInterfaceBlock1Field1Size = 1;
   const GLenum kInterfaceBlock1Field1Precision = GL_MEDIUM_FLOAT;
   const char* kInterfaceBlock1Field1Name = "field1";
   const bool kInterfaceBlock1Field1StaticUse = false;

   // Check we can create shader.
   Shader* shader1 = manager_.CreateShader(
       kClient1Id, kService1Id, kShader1Type);
   // Check shader got created.
   ASSERT_TRUE(shader1 != nullptr);
   EXPECT_EQ(kService1Id, shader1->service_id());
   // Check if the shader has correct type.
   EXPECT_EQ(kShader1Type, shader1->shader_type());
   EXPECT_FALSE(shader1->valid());
   EXPECT_FALSE(shader1->InUse());
   EXPECT_TRUE(shader1->source().empty());
   EXPECT_TRUE(shader1->log_info().empty());
   EXPECT_TRUE(shader1->last_compiled_source().empty());
   EXPECT_TRUE(shader1->translated_source().empty());
   EXPECT_EQ(0u, shader1->attrib_map().size());
   EXPECT_EQ(0u, shader1->uniform_map().size());
   EXPECT_EQ(0u, shader1->varying_map().size());
   EXPECT_EQ(Shader::kShaderStateWaiting, shader1->shader_state());

   // Check we can set its source.
   shader1->set_source(kClient1Source);
   EXPECT_STREQ(kClient1Source, shader1->source().c_str());
   EXPECT_TRUE(shader1->last_compiled_source().empty());

   // Check that DoCompile() will not work if RequestCompile() was not called.
   shader1->DoCompile();
   EXPECT_EQ(Shader::kShaderStateWaiting, shader1->shader_state());
   EXPECT_FALSE(shader1->valid());

   // Check RequestCompile() will update the state and last compiled source, but
   // still keep the actual compile state invalid.
   scoped_refptr<ShaderTranslatorInterface> translator(new MockShaderTranslator);
   shader1->RequestCompile(translator, Shader::kANGLE);
   EXPECT_EQ(Shader::kShaderStateCompileRequested, shader1->shader_state());
   EXPECT_STREQ(kClient1Source, shader1->last_compiled_source().c_str());
   EXPECT_FALSE(shader1->valid());

   // Check DoCompile() will set compilation states, log, translated source,
   // shader variables, and name mapping.
   const std::string kLog = "foo";
   const std::string kTranslatedSource = "poo";

   AttributeMap attrib_map;
   attrib_map[kAttrib1Name] = TestHelper::ConstructAttribute(
       kAttrib1Type, kAttrib1Size, kAttrib1Precision,
       kAttribStaticUse, kAttrib1Name);
   attrib_map[kAttrib2Name] = TestHelper::ConstructAttribute(
       kAttrib2Type, kAttrib2Size, kAttrib2Precision,
       kAttribStaticUse, kAttrib2Name);
   UniformMap uniform_map;
   uniform_map[kUniform1Name] = TestHelper::ConstructUniform(
       kUniform1Type, kUniform1Size, kUniform1Precision,
       kUniform1StaticUse, kUniform1Name);
   uniform_map[kUniform2Name] = TestHelper::ConstructUniform(
       kUniform2Type, kUniform2Size, kUniform2Precision,
       kUniform2StaticUse, kUniform2Name);
   VaryingMap varying_map;
   varying_map[kVarying1Name] = TestHelper::ConstructVarying(
       kVarying1Type, kVarying1Size, kVarying1Precision,
       kVarying1StaticUse, kVarying1Name);
   OutputVariableList output_variable_list;
   output_variable_list.push_back(TestHelper::ConstructOutputVariable(
       kOutputVariable1Type, kOutputVariable1Size, kOutputVariable1Precision,
       kOutputVariable1StaticUse, kOutputVariable1Name));

   InterfaceBlockMap interface_block_map;
   std::vector<sh::InterfaceBlockField> interface_block1_fields;
   interface_block1_fields.push_back(TestHelper::ConstructInterfaceBlockField(
       kInterfaceBlock1Field1Type, kInterfaceBlock1Field1Size,
       kInterfaceBlock1Field1Precision, kInterfaceBlock1Field1StaticUse,
       kInterfaceBlock1Field1Name));
   interface_block_map[kInterfaceBlock1Name] =
       TestHelper::ConstructInterfaceBlock(
           kInterfaceBlock1Size, kInterfaceBlock1Layout,
           kInterfaceBlock1RowMajor, kInterfaceBlock1StaticUse,
           kInterfaceBlock1Name, kInterfaceBlock1InstanceName,
           interface_block1_fields);

   TestHelper::SetShaderStates(gl_.get(), shader1, true, &kLog,
                               &kTranslatedSource, nullptr, &attrib_map,
                               &uniform_map, &varying_map, &interface_block_map,
                               &output_variable_list, nullptr);

   EXPECT_TRUE(shader1->valid());
   // When compilation succeeds, no log is recorded.
   EXPECT_STREQ("", shader1->log_info().c_str());
   EXPECT_STREQ(kClient1Source, shader1->last_compiled_source().c_str());
   EXPECT_STREQ(kTranslatedSource.c_str(), shader1->translated_source().c_str());

   // Check varying infos got copied.
   EXPECT_EQ(attrib_map.size(), shader1->attrib_map().size());
   for (AttributeMap::const_iterator it = attrib_map.begin();
        it != attrib_map.end(); ++it) {
     const sh::Attribute* variable_info = shader1->GetAttribInfo(it->first);
     ASSERT_TRUE(variable_info != nullptr);
     EXPECT_EQ(it->second.type, variable_info->type);
     EXPECT_EQ(it->second.getOutermostArraySize(),
               variable_info->getOutermostArraySize());
     EXPECT_EQ(it->second.precision, variable_info->precision);
     EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
     EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
     EXPECT_STREQ(it->second.name.c_str(),
                  shader1->GetOriginalNameFromHashedName(it->first)->c_str());
   }
   // Check uniform infos got copied.
   EXPECT_EQ(uniform_map.size(), shader1->uniform_map().size());
   for (UniformMap::const_iterator it = uniform_map.begin();
        it != uniform_map.end(); ++it) {
     const sh::Uniform* variable_info = shader1->GetUniformInfo(it->first);
     ASSERT_TRUE(variable_info != nullptr);
     EXPECT_EQ(it->second.type, variable_info->type);
     EXPECT_EQ(it->second.getOutermostArraySize(),
               variable_info->getOutermostArraySize());
     EXPECT_EQ(it->second.precision, variable_info->precision);
     EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
     EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
     EXPECT_STREQ(it->second.name.c_str(),
                  shader1->GetOriginalNameFromHashedName(it->first)->c_str());
   }
   // Check varying infos got copied.
   EXPECT_EQ(varying_map.size(), shader1->varying_map().size());
   for (VaryingMap::const_iterator it = varying_map.begin();
        it != varying_map.end(); ++it) {
     const sh::Varying* variable_info = shader1->GetVaryingInfo(it->first);
     ASSERT_TRUE(variable_info != nullptr);
     EXPECT_EQ(it->second.type, variable_info->type);
     EXPECT_EQ(it->second.getOutermostArraySize(),
               variable_info->getOutermostArraySize());
     EXPECT_EQ(it->second.precision, variable_info->precision);
     EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
     EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
     EXPECT_STREQ(it->second.name.c_str(),
                  shader1->GetOriginalNameFromHashedName(it->first)->c_str());
   }
   // Check interface block infos got copied.
   EXPECT_EQ(interface_block_map.size(), shader1->interface_block_map().size());
   for (const auto& it : interface_block_map) {
     const sh::InterfaceBlock* block_info =
         shader1->GetInterfaceBlockInfo(it.first);
     ASSERT_TRUE(block_info != nullptr);
     EXPECT_EQ(it.second.arraySize, block_info->arraySize);
     EXPECT_EQ(it.second.layout, block_info->layout);
     EXPECT_EQ(it.second.isRowMajorLayout, block_info->isRowMajorLayout);
     EXPECT_EQ(it.second.staticUse, block_info->staticUse);
     EXPECT_STREQ(it.second.name.c_str(), block_info->name.c_str());
     EXPECT_STREQ(it.second.name.c_str(),
                  shader1->GetOriginalNameFromHashedName(it.first)->c_str());
     EXPECT_STREQ(it.second.instanceName.c_str(),
                  block_info->instanceName.c_str());
   }
   // Check interface block field infos got copied.
   const sh::InterfaceBlock* interface_block1_info =
       shader1->GetInterfaceBlockInfo(kInterfaceBlock1Name);
   EXPECT_EQ(interface_block1_fields.size(),
             interface_block1_info->fields.size());
   for (size_t f = 0; f < interface_block1_fields.size(); ++f) {
     const auto& exp = interface_block1_fields[f];
     const auto& act = interface_block1_info->fields[f];
     EXPECT_EQ(exp.type, act.type);
     EXPECT_EQ(exp.getOutermostArraySize(), act.getOutermostArraySize());
     EXPECT_EQ(exp.precision, act.precision);
     EXPECT_EQ(exp.staticUse, act.staticUse);
     EXPECT_STREQ(exp.name.c_str(), act.name.c_str());
     std::string full_name = interface_block1_info->name + "." + act.name;
     auto* original_basename = shader1->GetOriginalNameFromHashedName(full_name);
     ASSERT_TRUE(original_basename != nullptr);
     EXPECT_STREQ(kInterfaceBlock1Name, original_basename->c_str());
   }
   // Check output variable infos got copied.
   EXPECT_EQ(output_variable_list.size(),
             shader1->output_variable_list().size());
   for (auto it = output_variable_list.begin(); it != output_variable_list.end();
        ++it) {
     const sh::OutputVariable* variable_info =
         shader1->GetOutputVariableInfo(it->mappedName);
     ASSERT_TRUE(variable_info != nullptr);
     EXPECT_EQ(it->type, variable_info->type);
     EXPECT_EQ(it->getOutermostArraySize(),
               variable_info->getOutermostArraySize());
     EXPECT_EQ(it->precision, variable_info->precision);
     EXPECT_EQ(it->staticUse, variable_info->staticUse);
     EXPECT_STREQ(it->name.c_str(), variable_info->name.c_str());
     EXPECT_STREQ(
         it->name.c_str(),
         shader1->GetOriginalNameFromHashedName(it->mappedName)->c_str());
   }

   // Compile failure case.
   TestHelper::SetShaderStates(gl_.get(), shader1, false, &kLog,
                               &kTranslatedSource, nullptr, &attrib_map,
                               &uniform_map, &varying_map, nullptr,
                               &output_variable_list, nullptr);
   EXPECT_FALSE(shader1->valid());
   EXPECT_STREQ(kLog.c_str(), shader1->log_info().c_str());
   EXPECT_STREQ("", shader1->translated_source().c_str());
   EXPECT_TRUE(shader1->attrib_map().empty());
   EXPECT_TRUE(shader1->uniform_map().empty());
   EXPECT_TRUE(shader1->varying_map().empty());
   EXPECT_TRUE(shader1->output_variable_list().empty());
 }

 TEST_F(ShaderManagerTest, ShaderInfoUseCount) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLenum kShader1Type = GL_VERTEX_SHADER;
   // Check we can create shader.
   Shader* shader1 = manager_.CreateShader(
       kClient1Id, kService1Id, kShader1Type);
   // Check shader got created.
   ASSERT_TRUE(shader1 != nullptr);
   EXPECT_FALSE(shader1->InUse());
   EXPECT_FALSE(shader1->IsDeleted());
   manager_.UseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   manager_.UseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   EXPECT_CALL(*gl_, DeleteShader(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Delete(shader1);
   EXPECT_TRUE(shader1->IsDeleted());
   Shader* shader2 = manager_.GetShader(kClient1Id);
   EXPECT_EQ(shader1, shader2);
   manager_.UnuseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   manager_.UnuseShader(shader1);  // this should delete the info.
   shader2 = manager_.GetShader(kClient1Id);
   EXPECT_TRUE(shader2 == nullptr);

   shader1 = manager_.CreateShader(kClient1Id, kService1Id, kShader1Type);
   ASSERT_TRUE(shader1 != nullptr);
   EXPECT_FALSE(shader1->InUse());
   manager_.UseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   manager_.UseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   manager_.UnuseShader(shader1);
   EXPECT_TRUE(shader1->InUse());
   manager_.UnuseShader(shader1);
   EXPECT_FALSE(shader1->InUse());
   shader2 = manager_.GetShader(kClient1Id);
   EXPECT_EQ(shader1, shader2);
   EXPECT_CALL(*gl_, DeleteShader(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Delete(shader1);  // this should delete the shader.
   shader2 = manager_.GetShader(kClient1Id);
   EXPECT_TRUE(shader2 == nullptr);
 }

 }  // namespace gles2
 }  // namespace gpu
	// 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/shader_manager.h"

	#include "gpu/command_buffer/service/gpu_service_test.h"
	#include "gpu/command_buffer/service/mocks.h"
	#include "gpu/command_buffer/service/test_helper.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/gl/gl_mock.h"

	using ::testing::Return;
	using ::testing::ReturnRef;

	namespace gpu {
	namespace gles2 {

	class ShaderManagerTest : public GpuServiceTest {
	public:
	ShaderManagerTest() : manager_(nullptr) {}

	~ShaderManagerTest() override { manager_.Destroy(false); }

	protected:
	ShaderManager manager_;
	};

	TEST_F(ShaderManagerTest, Basic) {
	const GLuint kClient1Id = 1;
	const GLuint kService1Id = 11;
	const GLenum kShader1Type = GL_VERTEX_SHADER;
	const GLuint kClient2Id = 2;
	// Check we can create shader.
	Shader* info0 = manager_.CreateShader(
	kClient1Id, kService1Id, kShader1Type);
	// Check shader got created.
	ASSERT_TRUE(info0 != nullptr);
	Shader* shader1 = manager_.GetShader(kClient1Id);
	ASSERT_EQ(info0, shader1);
	// Check we get nothing for a non-existent shader.
	EXPECT_TRUE(manager_.GetShader(kClient2Id) == nullptr);
	// Check we can't get the shader after we remove it.
	EXPECT_CALL(*gl_, DeleteShader(kService1Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.Delete(shader1);
	EXPECT_TRUE(manager_.GetShader(kClient1Id) == nullptr);
	}

	TEST_F(ShaderManagerTest, Destroy) {
	const GLuint kClient1Id = 1;
	const GLuint kService1Id = 11;
	const GLenum kShader1Type = GL_VERTEX_SHADER;
	// Check we can create shader.
	Shader* shader1 = manager_.CreateShader(
	kClient1Id, kService1Id, kShader1Type);
	// Check shader got created.
	ASSERT_TRUE(shader1 != nullptr);
	EXPECT_CALL(*gl_, DeleteShader(kService1Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.Destroy(true);
	// Check that resources got freed.
	shader1 = manager_.GetShader(kClient1Id);
	ASSERT_TRUE(shader1 == nullptr);
	}

	TEST_F(ShaderManagerTest, DeleteBug) {
	const GLuint kClient1Id = 1;
	const GLuint kClient2Id = 2;
	const GLuint kService1Id = 11;
	const GLuint kService2Id = 12;
	const GLenum kShaderType = GL_VERTEX_SHADER;
	// Check we can create shader.
	scoped_refptr<Shader> shader1(
	manager_.CreateShader(kClient1Id, kService1Id, kShaderType));
	scoped_refptr<Shader> shader2(
	manager_.CreateShader(kClient2Id, kService2Id, kShaderType));
	ASSERT_TRUE(shader1.get());
	ASSERT_TRUE(shader2.get());
	manager_.UseShader(shader1.get());
	manager_.Delete(shader1.get());

	EXPECT_CALL(*gl_, DeleteShader(kService2Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.Delete(shader2.get());
	EXPECT_TRUE(manager_.IsOwned(shader1.get()));
	EXPECT_FALSE(manager_.IsOwned(shader2.get()));

	EXPECT_CALL(*gl_, DeleteShader(kService1Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.UnuseShader(shader1.get());
	}

	TEST_F(ShaderManagerTest, DoCompile) {
	const GLuint kClient1Id = 1;
	const GLuint kService1Id = 11;
	const GLenum kShader1Type = GL_VERTEX_SHADER;
	const char* kClient1Source = "hello world";
	const GLenum kAttrib1Type = GL_FLOAT_VEC2;
	const GLint kAttrib1Size = 2;
	const GLenum kAttrib1Precision = GL_MEDIUM_FLOAT;
	const char* kAttrib1Name = "attr1";
	const GLenum kAttrib2Type = GL_FLOAT_VEC3;
	const GLint kAttrib2Size = 4;
	const GLenum kAttrib2Precision = GL_HIGH_FLOAT;
	const char* kAttrib2Name = "attr2";
	const bool kAttribStaticUse = false;
	const GLenum kUniform1Type = GL_FLOAT_MAT2;
	const GLint kUniform1Size = 3;
	const GLenum kUniform1Precision = GL_LOW_FLOAT;
	const bool kUniform1StaticUse = true;
	const char* kUniform1Name = "uni1";
	const GLenum kUniform2Type = GL_FLOAT_MAT3;
	const GLint kUniform2Size = 5;
	const GLenum kUniform2Precision = GL_MEDIUM_FLOAT;
	const bool kUniform2StaticUse = false;
	const char* kUniform2Name = "uni2";
	const GLenum kVarying1Type = GL_FLOAT_VEC4;
	const GLint kVarying1Size = 1;
	const GLenum kVarying1Precision = GL_HIGH_FLOAT;
	const bool kVarying1StaticUse = false;
	const char* kVarying1Name = "varying1";
	const GLenum kOutputVariable1Type = GL_FLOAT_VEC4;
	const GLint kOutputVariable1Size = 4;
	const GLenum kOutputVariable1Precision = GL_MEDIUM_FLOAT;
	const char* kOutputVariable1Name = "gl_FragColor";
	const bool kOutputVariable1StaticUse = true;

	const GLint kInterfaceBlock1Size = 1;
	const sh::BlockLayoutType kInterfaceBlock1Layout = sh::BLOCKLAYOUT_STANDARD;
	const bool kInterfaceBlock1RowMajor = false;
	const bool kInterfaceBlock1StaticUse = false;
	const char* kInterfaceBlock1Name = "block1";
	const char* kInterfaceBlock1InstanceName = "block1instance";
	const GLenum kInterfaceBlock1Field1Type = GL_FLOAT_VEC4;
	const GLint kInterfaceBlock1Field1Size = 1;
	const GLenum kInterfaceBlock1Field1Precision = GL_MEDIUM_FLOAT;
	const char* kInterfaceBlock1Field1Name = "field1";
	const bool kInterfaceBlock1Field1StaticUse = false;

	// Check we can create shader.
	Shader* shader1 = manager_.CreateShader(
	kClient1Id, kService1Id, kShader1Type);
	// Check shader got created.
	ASSERT_TRUE(shader1 != nullptr);
	EXPECT_EQ(kService1Id, shader1->service_id());
	// Check if the shader has correct type.
	EXPECT_EQ(kShader1Type, shader1->shader_type());
	EXPECT_FALSE(shader1->valid());
	EXPECT_FALSE(shader1->InUse());
	EXPECT_TRUE(shader1->source().empty());
	EXPECT_TRUE(shader1->log_info().empty());
	EXPECT_TRUE(shader1->last_compiled_source().empty());
	EXPECT_TRUE(shader1->translated_source().empty());
	EXPECT_EQ(0u, shader1->attrib_map().size());
	EXPECT_EQ(0u, shader1->uniform_map().size());
	EXPECT_EQ(0u, shader1->varying_map().size());
	EXPECT_EQ(Shader::kShaderStateWaiting, shader1->shader_state());

	// Check we can set its source.
	shader1->set_source(kClient1Source);
	EXPECT_STREQ(kClient1Source, shader1->source().c_str());
	EXPECT_TRUE(shader1->last_compiled_source().empty());

	// Check that DoCompile() will not work if RequestCompile() was not called.
	shader1->DoCompile();
	EXPECT_EQ(Shader::kShaderStateWaiting, shader1->shader_state());
	EXPECT_FALSE(shader1->valid());

	// Check RequestCompile() will update the state and last compiled source, but
	// still keep the actual compile state invalid.
	scoped_refptr<ShaderTranslatorInterface> translator(new MockShaderTranslator);
	shader1->RequestCompile(translator, Shader::kANGLE);
	EXPECT_EQ(Shader::kShaderStateCompileRequested, shader1->shader_state());
	EXPECT_STREQ(kClient1Source, shader1->last_compiled_source().c_str());
	EXPECT_FALSE(shader1->valid());

	// Check DoCompile() will set compilation states, log, translated source,
	// shader variables, and name mapping.
	const std::string kLog = "foo";
	const std::string kTranslatedSource = "poo";

	AttributeMap attrib_map;
	attrib_map[kAttrib1Name] = TestHelper::ConstructAttribute(
	kAttrib1Type, kAttrib1Size, kAttrib1Precision,
	kAttribStaticUse, kAttrib1Name);
	attrib_map[kAttrib2Name] = TestHelper::ConstructAttribute(
	kAttrib2Type, kAttrib2Size, kAttrib2Precision,
	kAttribStaticUse, kAttrib2Name);
	UniformMap uniform_map;
	uniform_map[kUniform1Name] = TestHelper::ConstructUniform(
	kUniform1Type, kUniform1Size, kUniform1Precision,
	kUniform1StaticUse, kUniform1Name);
	uniform_map[kUniform2Name] = TestHelper::ConstructUniform(
	kUniform2Type, kUniform2Size, kUniform2Precision,
	kUniform2StaticUse, kUniform2Name);
	VaryingMap varying_map;
	varying_map[kVarying1Name] = TestHelper::ConstructVarying(
	kVarying1Type, kVarying1Size, kVarying1Precision,
	kVarying1StaticUse, kVarying1Name);
	OutputVariableList output_variable_list;
	output_variable_list.push_back(TestHelper::ConstructOutputVariable(
	kOutputVariable1Type, kOutputVariable1Size, kOutputVariable1Precision,
	kOutputVariable1StaticUse, kOutputVariable1Name));

	InterfaceBlockMap interface_block_map;
	std::vector<sh::InterfaceBlockField> interface_block1_fields;
	interface_block1_fields.push_back(TestHelper::ConstructInterfaceBlockField(
	kInterfaceBlock1Field1Type, kInterfaceBlock1Field1Size,
	kInterfaceBlock1Field1Precision, kInterfaceBlock1Field1StaticUse,
	kInterfaceBlock1Field1Name));
	interface_block_map[kInterfaceBlock1Name] =
	TestHelper::ConstructInterfaceBlock(
	kInterfaceBlock1Size, kInterfaceBlock1Layout,
	kInterfaceBlock1RowMajor, kInterfaceBlock1StaticUse,
	kInterfaceBlock1Name, kInterfaceBlock1InstanceName,
	interface_block1_fields);

	TestHelper::SetShaderStates(gl_.get(), shader1, true, &kLog,
	&kTranslatedSource, nullptr, &attrib_map,
	&uniform_map, &varying_map, &interface_block_map,
	&output_variable_list, nullptr);

	EXPECT_TRUE(shader1->valid());
	// When compilation succeeds, no log is recorded.
	EXPECT_STREQ("", shader1->log_info().c_str());
	EXPECT_STREQ(kClient1Source, shader1->last_compiled_source().c_str());
	EXPECT_STREQ(kTranslatedSource.c_str(), shader1->translated_source().c_str());

	// Check varying infos got copied.
	EXPECT_EQ(attrib_map.size(), shader1->attrib_map().size());
	for (AttributeMap::const_iterator it = attrib_map.begin();
	it != attrib_map.end(); ++it) {
	const sh::Attribute* variable_info = shader1->GetAttribInfo(it->first);
	ASSERT_TRUE(variable_info != nullptr);
	EXPECT_EQ(it->second.type, variable_info->type);
	EXPECT_EQ(it->second.getOutermostArraySize(),
	variable_info->getOutermostArraySize());
	EXPECT_EQ(it->second.precision, variable_info->precision);
	EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
	EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
	EXPECT_STREQ(it->second.name.c_str(),
	shader1->GetOriginalNameFromHashedName(it->first)->c_str());
	}
	// Check uniform infos got copied.
	EXPECT_EQ(uniform_map.size(), shader1->uniform_map().size());
	for (UniformMap::const_iterator it = uniform_map.begin();
	it != uniform_map.end(); ++it) {
	const sh::Uniform* variable_info = shader1->GetUniformInfo(it->first);
	ASSERT_TRUE(variable_info != nullptr);
	EXPECT_EQ(it->second.type, variable_info->type);
	EXPECT_EQ(it->second.getOutermostArraySize(),
	variable_info->getOutermostArraySize());
	EXPECT_EQ(it->second.precision, variable_info->precision);
	EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
	EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
	EXPECT_STREQ(it->second.name.c_str(),
	shader1->GetOriginalNameFromHashedName(it->first)->c_str());
	}
	// Check varying infos got copied.
	EXPECT_EQ(varying_map.size(), shader1->varying_map().size());
	for (VaryingMap::const_iterator it = varying_map.begin();
	it != varying_map.end(); ++it) {
	const sh::Varying* variable_info = shader1->GetVaryingInfo(it->first);
	ASSERT_TRUE(variable_info != nullptr);
	EXPECT_EQ(it->second.type, variable_info->type);
	EXPECT_EQ(it->second.getOutermostArraySize(),
	variable_info->getOutermostArraySize());
	EXPECT_EQ(it->second.precision, variable_info->precision);
	EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
	EXPECT_STREQ(it->second.name.c_str(), variable_info->name.c_str());
	EXPECT_STREQ(it->second.name.c_str(),
	shader1->GetOriginalNameFromHashedName(it->first)->c_str());
	}
	// Check interface block infos got copied.
	EXPECT_EQ(interface_block_map.size(), shader1->interface_block_map().size());
	for (const auto& it : interface_block_map) {
	const sh::InterfaceBlock* block_info =
	shader1->GetInterfaceBlockInfo(it.first);
	ASSERT_TRUE(block_info != nullptr);
	EXPECT_EQ(it.second.arraySize, block_info->arraySize);
	EXPECT_EQ(it.second.layout, block_info->layout);
	EXPECT_EQ(it.second.isRowMajorLayout, block_info->isRowMajorLayout);
	EXPECT_EQ(it.second.staticUse, block_info->staticUse);
	EXPECT_STREQ(it.second.name.c_str(), block_info->name.c_str());
	EXPECT_STREQ(it.second.name.c_str(),
	shader1->GetOriginalNameFromHashedName(it.first)->c_str());
	EXPECT_STREQ(it.second.instanceName.c_str(),
	block_info->instanceName.c_str());
	}
	// Check interface block field infos got copied.
	const sh::InterfaceBlock* interface_block1_info =
	shader1->GetInterfaceBlockInfo(kInterfaceBlock1Name);
	EXPECT_EQ(interface_block1_fields.size(),
	interface_block1_info->fields.size());
	for (size_t f = 0; f < interface_block1_fields.size(); ++f) {
	const auto& exp = interface_block1_fields[f];
	const auto& act = interface_block1_info->fields[f];
	EXPECT_EQ(exp.type, act.type);
	EXPECT_EQ(exp.getOutermostArraySize(), act.getOutermostArraySize());
	EXPECT_EQ(exp.precision, act.precision);
	EXPECT_EQ(exp.staticUse, act.staticUse);
	EXPECT_STREQ(exp.name.c_str(), act.name.c_str());
	std::string full_name = interface_block1_info->name + "." + act.name;
	auto* original_basename = shader1->GetOriginalNameFromHashedName(full_name);
	ASSERT_TRUE(original_basename != nullptr);
	EXPECT_STREQ(kInterfaceBlock1Name, original_basename->c_str());
	}
	// Check output variable infos got copied.
	EXPECT_EQ(output_variable_list.size(),
	shader1->output_variable_list().size());
	for (auto it = output_variable_list.begin(); it != output_variable_list.end();
	++it) {
	const sh::OutputVariable* variable_info =
	shader1->GetOutputVariableInfo(it->mappedName);
	ASSERT_TRUE(variable_info != nullptr);
	EXPECT_EQ(it->type, variable_info->type);
	EXPECT_EQ(it->getOutermostArraySize(),
	variable_info->getOutermostArraySize());
	EXPECT_EQ(it->precision, variable_info->precision);
	EXPECT_EQ(it->staticUse, variable_info->staticUse);
	EXPECT_STREQ(it->name.c_str(), variable_info->name.c_str());
	EXPECT_STREQ(
	it->name.c_str(),
	shader1->GetOriginalNameFromHashedName(it->mappedName)->c_str());
	}

	// Compile failure case.
	TestHelper::SetShaderStates(gl_.get(), shader1, false, &kLog,
	&kTranslatedSource, nullptr, &attrib_map,
	&uniform_map, &varying_map, nullptr,
	&output_variable_list, nullptr);
	EXPECT_FALSE(shader1->valid());
	EXPECT_STREQ(kLog.c_str(), shader1->log_info().c_str());
	EXPECT_STREQ("", shader1->translated_source().c_str());
	EXPECT_TRUE(shader1->attrib_map().empty());
	EXPECT_TRUE(shader1->uniform_map().empty());
	EXPECT_TRUE(shader1->varying_map().empty());
	EXPECT_TRUE(shader1->output_variable_list().empty());
	}

	TEST_F(ShaderManagerTest, ShaderInfoUseCount) {
	const GLuint kClient1Id = 1;
	const GLuint kService1Id = 11;
	const GLenum kShader1Type = GL_VERTEX_SHADER;
	// Check we can create shader.
	Shader* shader1 = manager_.CreateShader(
	kClient1Id, kService1Id, kShader1Type);
	// Check shader got created.
	ASSERT_TRUE(shader1 != nullptr);
	EXPECT_FALSE(shader1->InUse());
	EXPECT_FALSE(shader1->IsDeleted());
	manager_.UseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	manager_.UseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	EXPECT_CALL(*gl_, DeleteShader(kService1Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.Delete(shader1);
	EXPECT_TRUE(shader1->IsDeleted());
	Shader* shader2 = manager_.GetShader(kClient1Id);
	EXPECT_EQ(shader1, shader2);
	manager_.UnuseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	manager_.UnuseShader(shader1); // this should delete the info.
	shader2 = manager_.GetShader(kClient1Id);
	EXPECT_TRUE(shader2 == nullptr);

	shader1 = manager_.CreateShader(kClient1Id, kService1Id, kShader1Type);
	ASSERT_TRUE(shader1 != nullptr);
	EXPECT_FALSE(shader1->InUse());
	manager_.UseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	manager_.UseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	manager_.UnuseShader(shader1);
	EXPECT_TRUE(shader1->InUse());
	manager_.UnuseShader(shader1);
	EXPECT_FALSE(shader1->InUse());
	shader2 = manager_.GetShader(kClient1Id);
	EXPECT_EQ(shader1, shader2);
	EXPECT_CALL(*gl_, DeleteShader(kService1Id))
	.Times(1)
	.RetiresOnSaturation();
	manager_.Delete(shader1); // this should delete the shader.
	shader2 = manager_.GetShader(kClient1Id);
	EXPECT_TRUE(shader2 == nullptr);
	}

	} // namespace gles2
	} // namespace gpu