Optimize glUniform* API type validation.

Previously the glUniform* API handlers validated the uniform type by
searching an array of enums (BaseUniformInfo).

Replaced with a simple AND test.
Each uniform has a bitmask (accepts_api_type) with it's supported APIs.

BUG=347358

Review URL: https://codereview.chromium.org/181563003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@256516 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 420 insertions, 177 deletions

diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 15ce17b..80340d7 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -504,12 +504,6 @@ void GLES2Decoder::EndDecoding() {}
 class GLES2DecoderImpl : public GLES2Decoder,
                          public FramebufferManager::TextureDetachObserver {
  public:
-  // Used by PrepForSetUniformByLocation to validate types.
-  struct BaseUniformInfo {
-    const GLenum* const valid_types;
-    size_t num_valid_types;
-  };
-
   explicit GLES2DecoderImpl(ContextGroup* group);
   virtual ~GLES2DecoderImpl();
 
@@ -1104,10 +1098,12 @@ class GLES2DecoderImpl : public GLES2Decoder,
   // errors if the current program is not valid. Returns true if the current
   // program is valid and the location exists. Adjusts count so it
   // does not overflow the uniform.
-  bool PrepForSetUniformByLocation(
-      GLint fake_location, const char* function_name,
-      const BaseUniformInfo& base_info,
-      GLint* real_location, GLenum* type, GLsizei* count);
+  bool PrepForSetUniformByLocation(GLint fake_location,
+                                   const char* function_name,
+                                   Program::UniformApiType api_type,
+                                   GLint* real_location,
+                                   GLenum* type,
+                                   GLsizei* count);
 
   // Gets the service id for any simulated backbuffer fbo.
   GLuint GetBackbufferServiceId() const;
@@ -5536,125 +5532,13 @@ bool GLES2DecoderImpl::CheckCurrentProgramForUniform(
   return location != -1;
 }
 
-namespace {
-
-static const GLenum valid_int_vec1_types_list[] = {
-  GL_INT,
-  GL_BOOL,
-  GL_SAMPLER_2D,
-  GL_SAMPLER_2D_RECT_ARB,
-  GL_SAMPLER_CUBE,
-  GL_SAMPLER_EXTERNAL_OES,
-};
-
-static const GLenum valid_int_vec2_types_list[] = {
-  GL_INT_VEC2,
-  GL_BOOL_VEC2,
-};
-
-static const GLenum valid_int_vec3_types_list[] = {
-  GL_INT_VEC3,
-  GL_BOOL_VEC3,
-};
-
-static const GLenum valid_int_vec4_types_list[] = {
-  GL_INT_VEC4,
-  GL_BOOL_VEC4,
-};
-
-static const GLenum valid_float_vec1_types_list[] = {
-  GL_FLOAT,
-  GL_BOOL,
-};
-
-static const GLenum valid_float_vec2_types_list[] = {
-  GL_FLOAT_VEC2,
-  GL_BOOL_VEC2,
-};
-
-static const GLenum valid_float_vec3_types_list[] = {
-  GL_FLOAT_VEC3,
-  GL_BOOL_VEC3,
-};
-
-static const GLenum valid_float_vec4_types_list[] = {
-  GL_FLOAT_VEC4,
-  GL_BOOL_VEC4,
-};
-
-static const GLenum valid_float_mat2_types_list[] = {
-  GL_FLOAT_MAT2,
-};
-
-static const GLenum valid_float_mat3_types_list[] = {
-  GL_FLOAT_MAT3,
-};
-
-static const GLenum valid_float_mat4_types_list[] = {
-  GL_FLOAT_MAT4,
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_int_vec1_base_info = {
-  valid_int_vec1_types_list,
-  arraysize(valid_int_vec1_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_int_vec2_base_info = {
-  valid_int_vec2_types_list,
-  arraysize(valid_int_vec2_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_int_vec3_base_info = {
-  valid_int_vec3_types_list,
-  arraysize(valid_int_vec3_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_int_vec4_base_info = {
-  valid_int_vec4_types_list,
-  arraysize(valid_int_vec4_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_vec1_base_info = {
-  valid_float_vec1_types_list,
-  arraysize(valid_float_vec1_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_vec2_base_info = {
-  valid_float_vec2_types_list,
-  arraysize(valid_float_vec2_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_vec3_base_info = {
-  valid_float_vec3_types_list,
-  arraysize(valid_float_vec3_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_vec4_base_info = {
-  valid_float_vec4_types_list,
-  arraysize(valid_float_vec4_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_mat2_base_info = {
-  valid_float_mat2_types_list,
-  arraysize(valid_float_mat2_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_mat3_base_info = {
-  valid_float_mat3_types_list,
-  arraysize(valid_float_mat3_types_list),
-};
-
-static const GLES2DecoderImpl::BaseUniformInfo valid_float_mat4_base_info = {
-  valid_float_mat4_types_list,
-  arraysize(valid_float_mat4_types_list),
-};
-
-}  // anonymous namespace.
-
 bool GLES2DecoderImpl::PrepForSetUniformByLocation(
-    GLint fake_location, const char* function_name,
-    const GLES2DecoderImpl::BaseUniformInfo& base_info,
-    GLint* real_location, GLenum* type, GLsizei* count) {
+    GLint fake_location,
+    const char* function_name,
+    Program::UniformApiType api_type,
+    GLint* real_location,
+    GLenum* type,
+    GLsizei* count) {
   DCHECK(type);
   DCHECK(count);
   DCHECK(real_location);
@@ -5671,14 +5555,8 @@ bool GLES2DecoderImpl::PrepForSetUniformByLocation(
         GL_INVALID_OPERATION, function_name, "unknown location");
     return false;
   }
-  bool okay = false;
-  for (size_t ii = 0; ii < base_info.num_valid_types; ++ii) {
-    if (base_info.valid_types[ii] == info->type) {
-      okay = true;
-      break;
-    }
-  }
-  if (!okay) {
+
+  if ((api_type & info->accepts_api_type) == 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name,
         "wrong uniform function for type");
@@ -5701,9 +5579,12 @@ void GLES2DecoderImpl::DoUniform1i(GLint fake_location, GLint v0) {
   GLenum type = 0;
   GLsizei count = 1;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform1i", valid_int_vec1_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform1i",
+                                   Program::kUniform1i,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (!state_.current_program->SetSamplers(
@@ -5719,9 +5600,12 @@ void GLES2DecoderImpl::DoUniform1iv(
     GLint fake_location, GLsizei count, const GLint *value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform1iv", valid_int_vec1_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform1iv",
+                                   Program::kUniform1i,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (type == GL_SAMPLER_2D || type == GL_SAMPLER_2D_RECT_ARB ||
@@ -5740,9 +5624,12 @@ void GLES2DecoderImpl::DoUniform1fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform1fv", valid_float_vec1_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform1fv",
+                                   Program::kUniform1f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (type == GL_BOOL) {
@@ -5760,9 +5647,12 @@ void GLES2DecoderImpl::DoUniform2fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform2fv", valid_float_vec2_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform2fv",
+                                   Program::kUniform2f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (type == GL_BOOL_VEC2) {
@@ -5781,9 +5671,12 @@ void GLES2DecoderImpl::DoUniform3fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform3fv", valid_float_vec3_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform3fv",
+                                   Program::kUniform3f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (type == GL_BOOL_VEC3) {
@@ -5802,9 +5695,12 @@ void GLES2DecoderImpl::DoUniform4fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform4fv", valid_float_vec4_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform4fv",
+                                   Program::kUniform4f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   if (type == GL_BOOL_VEC4) {
@@ -5823,9 +5719,12 @@ void GLES2DecoderImpl::DoUniform2iv(
     GLint fake_location, GLsizei count, const GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform2iv", valid_int_vec2_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform2iv",
+                                   Program::kUniform2i,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniform2iv(real_location, count, value);
@@ -5835,9 +5734,12 @@ void GLES2DecoderImpl::DoUniform3iv(
     GLint fake_location, GLsizei count, const GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform3iv", valid_int_vec3_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform3iv",
+                                   Program::kUniform3i,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniform3iv(real_location, count, value);
@@ -5847,9 +5749,12 @@ void GLES2DecoderImpl::DoUniform4iv(
     GLint fake_location, GLsizei count, const GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniform4iv", valid_int_vec4_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniform4iv",
+                                   Program::kUniform4i,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniform4iv(real_location, count, value);
@@ -5860,9 +5765,12 @@ void GLES2DecoderImpl::DoUniformMatrix2fv(
     const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniformMatrix2fv", valid_float_mat2_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniformMatrix2fv",
+                                   Program::kUniformMatrix2f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniformMatrix2fv(real_location, count, transpose, value);
@@ -5873,9 +5781,12 @@ void GLES2DecoderImpl::DoUniformMatrix3fv(
     const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniformMatrix3fv",  valid_float_mat3_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniformMatrix3fv",
+                                   Program::kUniformMatrix3f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniformMatrix3fv(real_location, count, transpose, value);
@@ -5886,9 +5797,12 @@ void GLES2DecoderImpl::DoUniformMatrix4fv(
     const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (!PrepForSetUniformByLocation(
-      fake_location, "glUniformMatrix4fv",  valid_float_mat4_base_info,
-      &real_location, &type, &count)) {
+  if (!PrepForSetUniformByLocation(fake_location,
+                                   "glUniformMatrix4fv",
+                                   Program::kUniformMatrix4f,
+                                   &real_location,
+                                   &type,
+                                   &count)) {
     return;
   }
   glUniformMatrix4fv(real_location, count, transpose, value);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
index 8c9c6ec..0c6d16b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
@@ -15,6 +15,7 @@
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
+using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
@@ -30,6 +31,198 @@ namespace gles2 {
 class GLES2DecoderTest2 : public GLES2DecoderTestBase {
  public:
   GLES2DecoderTest2() { }
+
+  void TestAcceptedUniform(GLenum uniform_type, uint32 accepts_apis) {
+    SetupShaderForUniform(uniform_type);
+    bool valid_uniform = false;
+
+    EXPECT_CALL(*gl_, Uniform1i(1, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform1iv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform2iv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform3iv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform4iv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform1f(1, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform1fv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform2fv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform3fv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, Uniform4fv(1, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, UniformMatrix2fv(1, _, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, UniformMatrix3fv(1, _, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*gl_, UniformMatrix4fv(1, _, _, _)).Times(AnyNumber());
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform1i;
+      cmds::Uniform1i cmd;
+      cmd.Init(1, 2);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform1i;
+      cmds::Uniform1iv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform2i;
+      cmds::Uniform2i cmd;
+      cmd.Init(1, 2, 3);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform2i;
+      cmds::Uniform2iv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform3i;
+      cmds::Uniform3i cmd;
+      cmd.Init(1, 2, 3, 4);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform3i;
+      cmds::Uniform3iv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform4i;
+      cmds::Uniform4i cmd;
+      cmd.Init(1, 2, 3, 4, 5);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform4i;
+      cmds::Uniform4iv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    ////////////////////
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform1f;
+      cmds::Uniform1f cmd;
+      cmd.Init(1, 2);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform1f;
+      cmds::Uniform1fv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform2f;
+      cmds::Uniform2f cmd;
+      cmd.Init(1, 2, 3);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform2f;
+      cmds::Uniform2fv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform3f;
+      cmds::Uniform3f cmd;
+      cmd.Init(1, 2, 3, 4);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform3f;
+      cmds::Uniform3fv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform4f;
+      cmds::Uniform4f cmd;
+      cmd.Init(1, 2, 3, 4, 5);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniform4f;
+      cmds::Uniform4fv cmd;
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniformMatrix2f;
+      cmds::UniformMatrix2fv cmd;
+      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniformMatrix3f;
+      cmds::UniformMatrix3fv cmd;
+      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+
+    {
+      valid_uniform = accepts_apis & Program::kUniformMatrix4f;
+      cmds::UniformMatrix4fv cmd;
+      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                GetGLError());
+    }
+  }
 };
 
 template <>
@@ -384,6 +577,66 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
 
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
+  TestAcceptedUniform(GL_INT, Program::kUniform1i);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
+  TestAcceptedUniform(GL_INT_VEC2, Program::kUniform2i);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
+  TestAcceptedUniform(GL_INT_VEC3, Program::kUniform3i);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
+  TestAcceptedUniform(GL_INT_VEC4, Program::kUniform4i);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
+  TestAcceptedUniform(GL_BOOL, Program::kUniform1i | Program::kUniform1f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
+  TestAcceptedUniform(GL_BOOL_VEC2, Program::kUniform2i | Program::kUniform2f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
+  TestAcceptedUniform(GL_BOOL_VEC3, Program::kUniform3i | Program::kUniform3f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
+  TestAcceptedUniform(GL_BOOL_VEC4, Program::kUniform4i | Program::kUniform4f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
+  TestAcceptedUniform(GL_FLOAT, Program::kUniform1f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
+  TestAcceptedUniform(GL_FLOAT_VEC2, Program::kUniform2f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
+  TestAcceptedUniform(GL_FLOAT_VEC3, Program::kUniform3f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
+  TestAcceptedUniform(GL_FLOAT_VEC4, Program::kUniform4f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
+  TestAcceptedUniform(GL_FLOAT_MAT2, Program::kUniformMatrix2f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
+  TestAcceptedUniform(GL_FLOAT_MAT3, Program::kUniformMatrix3f);
+}
+
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
+  TestAcceptedUniform(GL_FLOAT_MAT4, Program::kUniformMatrix4f);
+}
+
 }  // namespace gles2
 }  // namespace gpu
 
diff --git a/gpu/command_buffer/service/program_manager.cc b/gpu/command_buffer/service/program_manager.cc
index 8e0ff92..44169b8 100644
--- a/gpu/command_buffer/service/program_manager.cc
+++ b/gpu/command_buffer/service/program_manager.cc
@@ -125,16 +125,77 @@ Program::UniformInfo::UniformInfo()
       is_array(false) {
 }
 
-Program::UniformInfo::UniformInfo(
-    GLsizei _size,
-    GLenum _type,
-    int _fake_location_base,
-    const std::string& _name)
+Program::UniformInfo::UniformInfo(GLsizei _size,
+                                  GLenum _type,
+                                  int _fake_location_base,
+                                  const std::string& _name)
     : size(_size),
       type(_type),
+      accepts_api_type(0),
       fake_location_base(_fake_location_base),
       is_array(false),
       name(_name) {
+  switch (type) {
+    case GL_INT:
+      accepts_api_type = kUniform1i;
+      break;
+    case GL_INT_VEC2:
+      accepts_api_type = kUniform2i;
+      break;
+    case GL_INT_VEC3:
+      accepts_api_type = kUniform3i;
+      break;
+    case GL_INT_VEC4:
+      accepts_api_type = kUniform4i;
+      break;
+
+    case GL_BOOL:
+      accepts_api_type = kUniform1i | kUniform1f;
+      break;
+    case GL_BOOL_VEC2:
+      accepts_api_type = kUniform2i | kUniform2f;
+      break;
+    case GL_BOOL_VEC3:
+      accepts_api_type = kUniform3i | kUniform3f;
+      break;
+    case GL_BOOL_VEC4:
+      accepts_api_type = kUniform4i | kUniform4f;
+      break;
+
+    case GL_FLOAT:
+      accepts_api_type = kUniform1f;
+      break;
+    case GL_FLOAT_VEC2:
+      accepts_api_type = kUniform2f;
+      break;
+    case GL_FLOAT_VEC3:
+      accepts_api_type = kUniform3f;
+      break;
+    case GL_FLOAT_VEC4:
+      accepts_api_type = kUniform4f;
+      break;
+
+    case GL_FLOAT_MAT2:
+      accepts_api_type = kUniformMatrix2f;
+      break;
+    case GL_FLOAT_MAT3:
+      accepts_api_type = kUniformMatrix3f;
+      break;
+    case GL_FLOAT_MAT4:
+      accepts_api_type = kUniformMatrix4f;
+      break;
+
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_RECT_ARB:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_3D_OES:
+    case GL_SAMPLER_EXTERNAL_OES:
+      accepts_api_type = kUniform1i;
+      break;
+    default:
+      NOTREACHED() << "Unhandled UniformInfo type " << type;
+      break;
+  }
 }
 
 Program::UniformInfo::~UniformInfo() {}
diff --git a/gpu/command_buffer/service/program_manager.h b/gpu/command_buffer/service/program_manager.h
index 9ec31b9..c1bf3a4 100644
--- a/gpu/command_buffer/service/program_manager.h
+++ b/gpu/command_buffer/service/program_manager.h
@@ -38,6 +38,20 @@ class GPU_EXPORT Program : public base::RefCounted<Program> {
     kCountAll
   };
 
+  enum UniformApiType {
+    kUniform1i = 1 << 0,
+    kUniform2i = 1 << 1,
+    kUniform3i = 1 << 2,
+    kUniform4i = 1 << 3,
+    kUniform1f = 1 << 4,
+    kUniform2f = 1 << 5,
+    kUniform3f = 1 << 6,
+    kUniform4f = 1 << 7,
+    kUniformMatrix2f = 1 << 8,
+    kUniformMatrix3f = 1 << 9,
+    kUniformMatrix4f = 1 << 10,
+  };
+
   struct UniformInfo {
     UniformInfo();
     UniformInfo(
@@ -56,6 +70,7 @@ class GPU_EXPORT Program : public base::RefCounted<Program> {
 
     GLsizei size;
     GLenum type;
+    uint32 accepts_api_type;
     GLint fake_location_base;
     bool is_array;
     std::string name;