Remove shm versions of immediate commands from command buffer

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 "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
@@ skipping 43 matching lines @@
       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));
+      cmds::Uniform1ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform1ivImmediate>();
+      GLint data[2][1] = {{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::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));
+      cmds::Uniform2ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform2ivImmediate>();
+      GLint data[2][2] = {{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::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));
+      cmds::Uniform3ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform3ivImmediate>();
+      GLint data[2][3] = {{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::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));
+      cmds::Uniform4ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform4ivImmediate>();
+      GLint 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::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));
+      cmds::Uniform1fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform1fvImmediate>();
+      GLfloat data[2][1] = {{0.0f}};
+      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::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));
+      cmds::Uniform2fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform2fvImmediate>();
+      GLfloat data[2][2] = {{0.0f}};
+      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::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));
+      cmds::Uniform3fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform3fvImmediate>();
+      GLfloat data[2][3] = {{0.0f}};
+      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::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));
+      cmds::Uniform4fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform4fvImmediate>();
+      GLfloat data[2][4] = {{0.0f}};
+      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::UniformMatrix2fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix2fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
+      GLfloat data[2][2 * 2] = {{0.0f}};
+
+      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::kUniformMatrix3f;
-      cmds::UniformMatrix3fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix3fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
+      GLfloat data[2][3 * 3] = {{0.0f}};
+      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::kUniformMatrix4f;
-      cmds::UniformMatrix4fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix4fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
+      GLfloat data[2][4 * 4] = {{0.0f}};
+      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());
     }
   }
 };
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest2, ::testing::Bool());
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXT, 0>(
-    bool valid) {
-  if (!valid) {
-    // Make the client_query_id_ so that trying to make it again
-    // will fail.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXTImmediate, 0>(
     bool valid) {
   if (!valid) {
     // Make the client_query_id_ so that trying to make it again
     // will fail.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+    cmds::GenQueriesEXTImmediate& cmd =
+        *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
+    cmd.Init(1, &client_query_id_);
+    EXPECT_EQ(error::kNoError,
+              ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
   }
 };
 
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXT, 0>(
-    bool valid) {
-  if (valid) {
-    // Make the client_query_id_ so that trying to delete it will succeed.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-};
-
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
     bool valid) {
   if (valid) {
     // Make the client_query_id_ so that trying to delete it will succeed.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+    cmds::GenQueriesEXTImmediate& cmd =
+        *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
+    cmd.Init(1, &client_query_id_);
+    EXPECT_EQ(error::kNoError,
+              ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
   }
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
     bool /* valid */) {
   const GLuint kClientVertexShaderId = 5001;
   const GLuint kServiceVertexShaderId = 6001;
   const GLuint kClientFragmentShaderId = 5002;
   const GLuint kServiceFragmentShaderId = 6002;
@@ skipping 76 matching lines @@
       .RetiresOnSaturation();
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2f, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC2);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC2);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC2);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC2);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC2);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2ivImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC2);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3f, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC3);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC3);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC3);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC3);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC3);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3ivImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC3);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4f, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC4);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4i, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC4);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC4);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC4);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC4);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4ivImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT_VEC4);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT2);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT2);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT3);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT3);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT4);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT4);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::RenderbufferStorage, 0>(
     bool valid) {
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
@@ skipping 17 matching lines @@
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 };
 
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>(
     bool /* valid */) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfv, 0>(
-    bool /* valid */) {
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>(
     bool /* valid */) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteriv, 0>(
-    bool /* valid */) {
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
     bool /* valid */) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 };
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
 
 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
   TestAcceptedUniform(GL_INT, Program::kUniform1i);
 }
@@ skipping 50 matching lines @@
   TestAcceptedUniform(GL_FLOAT_MAT3, Program::kUniformMatrix3f);
 }
 
 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
   TestAcceptedUniform(GL_FLOAT_MAT4, Program::kUniformMatrix4f);
 }
 
 }  // namespace gles2
 }  // namespace gpu