Make OpenGL string entry points validate the string

gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

 // Copyright (c) 2011 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 "base/atomicops.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/gl_mock.h"
@@ skipping 1133 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(kSourceSize + 1, bucket->size());
   EXPECT_EQ(0, memcmp(bucket->GetData(0, bucket->size()), kSource,
                       bucket->size()));
 }
 
 TEST_F(GLES2DecoderTest, ShaderSourceInvalidArgs) {
   const char kSource[] = "hello";
+  const char kBadSource[] = "hello\a";
   const uint32 kSourceSize = sizeof(kSource) - 1;
+  const uint32 kBadSourceSize = sizeof(kBadSource) - 1;
   memcpy(shared_memory_address_, kSource, kSourceSize);
   ShaderSource cmd;
   cmd.Init(kInvalidClientId,
            kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   cmd.Init(client_program_id_,
            kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
   cmd.Init(client_shader_id_,
            kInvalidSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_shader_id_,
            kSharedMemoryId, kInvalidSharedMemoryOffset, kSourceSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_shader_id_,
            kSharedMemoryId, kSharedMemoryOffset, kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
+  memcpy(shared_memory_address_, kBadSource, kBadSourceSize);
+  cmd.Init(client_program_id_,
+           kSharedMemoryId, kSharedMemoryOffset, kBadSourceSize);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest, ShaderSourceImmediateAndGetShaderSourceValidArgs) {
   const uint32 kBucketId = 123;
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
   ShaderSourceImmediate& cmd = *GetImmediateAs<ShaderSourceImmediate>();
   cmd.Init(client_shader_id_, kSourceSize);
   memcpy(GetImmediateDataAs<void*>(&cmd), kSource, kSourceSize);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, kSourceSize));
@@ skipping 731 matching lines @@
   memcpy(shared_memory_address_, kName, kNameSize);
   BindAttribLocation cmd;
   cmd.Init(client_program_id_, kLocation, kSharedMemoryId, kSharedMemoryOffset,
            kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
   const GLint kLocation = 2;
   const char* kName = "testing";
+  const char* kBadName = "test\aing";
   const uint32 kNameSize = strlen(kName);
+  const uint32 kBadNameSize = strlen(kBadName);
   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
+  memcpy(shared_memory_address_, kName, kNameSize);
   BindAttribLocation cmd;
   cmd.Init(kInvalidClientId, kLocation,
            kSharedMemoryId, kSharedMemoryOffset, kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(client_program_id_, kLocation,
            kInvalidSharedMemoryId, kSharedMemoryOffset, kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_, kLocation,
            kSharedMemoryId, kInvalidSharedMemoryOffset, kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_, kLocation,
            kSharedMemoryId, kSharedMemoryOffset, kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
+  memcpy(shared_memory_address_, kBadName, kBadNameSize);
+  cmd.Init(client_program_id_, kLocation,
+           kSharedMemoryId, kSharedMemoryOffset, kBadNameSize);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest, BindAttribLocationImmediate) {
   const GLint kLocation = 2;
   const char* kName = "testing";
   const uint32 kNameSize = strlen(kName);
   EXPECT_CALL(
       *gl_, BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
       .Times(1);
   BindAttribLocationImmediate& cmd =
@@ skipping 69 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
   const uint32 kNameSize = strlen(kAttrib2Name);
+  const char* kBadName = "foo\abar";
+  const uint32 kBadNameSize = strlen(kBadName);
   typedef GetAttribLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kAttrib2Name, kNameSize);
   GetAttribLocation cmd;
   cmd.Init(kInvalidClientId,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
@@ skipping 25 matching lines @@
            kSharedMemoryId, kInvalidSharedMemoryOffset,
            kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
+  memcpy(name, kBadName, kBadNameSize);
+  cmd.Init(client_program_id_,
+           kSharedMemoryId, kNameOffset,
+           kSharedMemoryId, kSharedMemoryOffset,
+           kBadNameSize);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationImmediate) {
   const uint32 kNameSize = strlen(kAttrib2Name);
   const char* kNonExistentName = "foobar";
   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
   typedef GetAttribLocationImmediate::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   GetAttribLocationImmediate& cmd =
@@ skipping 102 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
   const uint32 kNameSize = strlen(kUniform2Name);
+  const char* kBadName = "foo\abar";
+  const uint32 kBadNameSize = strlen(kBadName);
   typedef GetUniformLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kUniform2Name, kNameSize);
   GetUniformLocation cmd;
   cmd.Init(kInvalidClientId,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
@@ skipping 25 matching lines @@
            kSharedMemoryId, kInvalidSharedMemoryOffset,
            kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
+  memcpy(name, kBadName, kBadNameSize);
+  cmd.Init(client_program_id_,
+           kSharedMemoryId, kNameOffset,
+           kSharedMemoryId, kSharedMemoryOffset,
+           kBadNameSize);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationImmediate) {
   const uint32 kNameSize = strlen(kUniform2Name);
   const char* kNonExistentName = "foobar";
   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
   typedef GetUniformLocationImmediate::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   GetUniformLocationImmediate& cmd =
@@ skipping 2685 matching lines @@
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 // TODO(gman): UseProgram
 
 // TODO(gman): SwapBuffers
 
 }  // namespace gles2
 }  // namespace gpu