UniformMatrix* supports transpose is true in ES3 semantic

gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdint.h>
 
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 48 matching lines @@
     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());
     if (es3_enabled) {
       EXPECT_CALL(*gl_, Uniform1uiv(1, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, Uniform2uiv(1, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, Uniform3uiv(1, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, Uniform4uiv(1, _, _)).Times(AnyNumber());
+      EXPECT_CALL(*gl_, UniformMatrix2fv(1, _, _, _)).Times(AnyNumber());
+      EXPECT_CALL(*gl_, UniformMatrix3fv(1, _, _, _)).Times(AnyNumber());
+      EXPECT_CALL(*gl_, UniformMatrix4fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix2x3fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix2x4fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix3x2fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix3x4fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix4x2fv(1, _, _, _)).Times(AnyNumber());
       EXPECT_CALL(*gl_, UniformMatrix4x3fv(1, _, _, _)).Times(AnyNumber());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniform1i;
@@ skipping 156 matching lines @@
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix2f;
       cmds::UniformMatrix2fvImmediate& cmd =
           *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
       GLfloat data[2][2 * 2] = {{0.0f}};
 
-      cmd.Init(1, 2, &data[0][0]);
+      cmd.Init(1, 2, false, &data[0][0]);

[Zhenyao Mo, 2016/02/05 17:31:59]

Here you should also test with transpose == true and INVALID_VALUE is generated.
Also the below two cases.

[qiankun, 2016/02/06 03:02:56]

Added test cases for gles2. Removed duplicate test cases under if
(es3_enabled).{}, because test cases here will be executed both in gles2 and
gles3 context.

       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix3f;
       cmds::UniformMatrix3fvImmediate& cmd =
           *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
       GLfloat data[2][3 * 3] = {{0.0f}};
-      cmd.Init(1, 2, &data[0][0]);
+      cmd.Init(1, 2, false, &data[0][0]);
       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix4f;
       cmds::UniformMatrix4fvImmediate& cmd =
           *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
       GLfloat data[2][4 * 4] = {{0.0f}};
-      cmd.Init(1, 2, &data[0][0]);
+      cmd.Init(1, 2, false, &data[0][0]);
       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     if (es3_enabled) {
       {
         valid_uniform = accepts_apis & Program::kUniform1ui;
         cmds::Uniform1ui cmd;
         cmd.Init(1, 2);
@@ skipping 67 matching lines @@
         cmds::Uniform4uivImmediate& cmd =
             *GetImmediateAs<cmds::Uniform4uivImmediate>();
         GLuint data[2][4] = {{0}};
         cmd.Init(1, 2, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
+        valid_uniform = accepts_apis & Program::kUniformMatrix2f;
+        cmds::UniformMatrix2fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
+        GLfloat data[2][2 * 2] = {{0.0f}};
+
+        cmd.Init(1, 2, false, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix3f;
+        cmds::UniformMatrix3fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
+        GLfloat data[2][3 * 3] = {{0.0f}};
+        cmd.Init(1, 2, false, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix4f;
+        cmds::UniformMatrix4fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
+        GLfloat data[2][4 * 4] = {{0.0f}};
+        cmd.Init(1, 2, false, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
         valid_uniform = accepts_apis & Program::kUniformMatrix2x3f;
         cmds::UniformMatrix2x3fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix2x3fvImmediate>();
         GLfloat data[2][2 * 3] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
         valid_uniform = accepts_apis & Program::kUniformMatrix2x4f;
         cmds::UniformMatrix2x4fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix2x4fvImmediate>();
         GLfloat data[2][2 * 4] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
         valid_uniform = accepts_apis & Program::kUniformMatrix3x2f;
         cmds::UniformMatrix3x2fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix3x2fvImmediate>();
         GLfloat data[2][3 * 2] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
         valid_uniform = accepts_apis & Program::kUniformMatrix3x4f;
         cmds::UniformMatrix3x4fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix3x4fvImmediate>();
         GLfloat data[2][3 * 4] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
         valid_uniform = accepts_apis & Program::kUniformMatrix4x2f;
         cmds::UniformMatrix4x2fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix4x2fvImmediate>();
         GLfloat data[2][4 * 2] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
       }
 
       {
         valid_uniform = accepts_apis & Program::kUniformMatrix4x3f;
         cmds::UniformMatrix4x3fvImmediate& cmd =
             *GetImmediateAs<cmds::UniformMatrix4x3fvImmediate>();
         GLfloat data[2][4 * 3] = {{0.0f}};
 
-        cmd.Init(1, 2, &data[0][0]);
+        cmd.Init(1, 2, false, &data[0][0]);
         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                   GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix2f;
+        cmds::UniformMatrix2fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
+        GLfloat data[2][2 * 2] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix3f;
+        cmds::UniformMatrix3fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
+        GLfloat data[2][3 * 3] = {{0.0f}};
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix4f;
+        cmds::UniformMatrix4fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
+        GLfloat data[2][4 * 4] = {{0.0f}};
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix2x3f;
+        cmds::UniformMatrix2x3fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix2x3fvImmediate>();
+        GLfloat data[2][2 * 3] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix2x4f;
+        cmds::UniformMatrix2x4fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix2x4fvImmediate>();
+        GLfloat data[2][2 * 4] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix3x2f;
+        cmds::UniformMatrix3x2fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix3x2fvImmediate>();
+        GLfloat data[2][3 * 2] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix3x4f;
+        cmds::UniformMatrix3x4fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix3x4fvImmediate>();
+        GLfloat data[2][3 * 4] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix4x2f;
+        cmds::UniformMatrix4x2fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix4x2fvImmediate>();
+        GLfloat data[2][4 * 2] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
+      }
+
+      {
+        valid_uniform = accepts_apis & Program::kUniformMatrix4x3f;
+        cmds::UniformMatrix4x3fvImmediate& cmd =
+            *GetImmediateAs<cmds::UniformMatrix4x3fvImmediate>();
+        GLfloat data[2][4 * 3] = {{0.0f}};
+
+        cmd.Init(1, 2, true, &data[0][0]);
+        EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
+        EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
+                  GetGLError());
       }
     }
   }
 };
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest2, ::testing::Bool());
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
     bool /* valid */) {
@@ skipping 472 matching lines @@
   TestAcceptedUniform(GL_FLOAT_MAT4x2, Program::kUniformMatrix4x2f, true);
 }
 
 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4x3) {
   TestAcceptedUniform(GL_FLOAT_MAT4x3, Program::kUniformMatrix4x3f, true);
 }
 
 }  // namespace gles2
 }  // namespace gpu