Revert of Initialize buffers before allowing access to them.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc

 // Copyright 2015 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 <stdint.h>
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
 
 using ::gl::MockGLInterface;
@@ skipping 50 matching lines @@
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgPointee<1>(kNewServiceId));
   SpecializedSetup<BindBufferRange, 0>(true);
   BindBufferRange cmd;
   cmd.Init(GL_TRANSFORM_FEEDBACK_BUFFER, 2, kNewClientId, 4, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeUnmapBufferReadSucceeds) {
+TEST_P(GLES2DecoderTest, MapBufferRangeUnmapBufferReadSucceeds) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_READ_BIT;
 
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
@@ skipping 11 matching lines @@
                 MapBufferRange(kTarget, kOffset, kSize, kAccess))
         .WillOnce(Return(&data[0]))
         .RetiresOnSaturation();
 
     typedef MapBufferRange::Result Result;
     Result* result = GetSharedMemoryAs<Result*>();
 
     MapBufferRange cmd;
     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
              result_shm_id, result_shm_offset);
+    decoder_->set_unsafe_es3_apis_enabled(false);
+    *result = 0;
+    EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+    EXPECT_EQ(0u, *result);
+    decoder_->set_unsafe_es3_apis_enabled(true);
     *result = 0;
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
     EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
     EXPECT_EQ(1u, *result);
   }
 
   {  // UnmapBuffer
     EXPECT_CALL(*gl_, UnmapBuffer(kTarget))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 
     UnmapBuffer cmd;
     cmd.Init(kTarget);
+    decoder_->set_unsafe_es3_apis_enabled(false);
+    EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+    decoder_->set_unsafe_es3_apis_enabled(true);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeUnmapBufferWriteSucceeds) {
+TEST_P(GLES2DecoderTest, MapBufferRangeUnmapBufferWriteSucceeds) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLsizeiptr kTotalSize = kOffset + kSize;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
   const GLbitfield kMappedAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
@@ skipping 26 matching lines @@
 
   {  // MapBufferRange succeeds
     EXPECT_CALL(*gl_,
                 MapBufferRange(kTarget, kOffset, kSize, kMappedAccess))
         .WillOnce(Return(&gpu_data[kOffset]))
         .RetiresOnSaturation();
 
     MapBufferRange cmd;
     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
              result_shm_id, result_shm_offset);
+    decoder_->set_unsafe_es3_apis_enabled(false);
+    *result = 0;
+    EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+    EXPECT_EQ(0u, *result);
+    decoder_->set_unsafe_es3_apis_enabled(true);
     *result = 0;
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(1u, *result);
     // Verify the buffer range from GPU is copied to client mem.
     EXPECT_EQ(0, memcmp(&gpu_data[kOffset], client_data, kSize));
   }
 
   // Update the client mem.
   const int8_t kValue0 = 21;
   memset(client_data, kValue0, kSize);
 
   {  // UnmapBuffer succeeds
     EXPECT_CALL(*gl_, UnmapBuffer(kTarget))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 
     UnmapBuffer cmd;
     cmd.Init(kTarget);
+    decoder_->set_unsafe_es3_apis_enabled(false);
+    EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+    decoder_->set_unsafe_es3_apis_enabled(true);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
     // Verify the GPU mem and shadow data are both updated
     for (GLsizeiptr ii = 0; ii < kTotalSize; ++ii) {
       if (ii < kOffset) {
         EXPECT_EQ(static_cast<int8_t>(ii % 128), gpu_data[ii]);
         EXPECT_EQ(static_cast<int8_t>(ii % 128), shadow_data[ii]);
       } else {
         EXPECT_EQ(kValue0, gpu_data[ii]);
         EXPECT_EQ(kValue0, shadow_data[ii]);
@@ skipping 108 matching lines @@
       } else {
         EXPECT_EQ(static_cast<int8_t>(ii % 128), gpu_data[ii]);
         EXPECT_EQ(static_cast<int8_t>(ii % 128), shadow_data[ii]);
       }
     }
   }
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeNotInitFails) {
+TEST_P(GLES2DecoderTest, MapBufferRangeNotInitFails) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_READ_BIT;
   std::vector<int8_t> data(kSize);
 
   typedef MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = 1;  // Any value other than 0.
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
            result_shm_id, result_shm_offset);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeWriteInvalidateRangeSucceeds) {
+TEST_P(GLES2DecoderTest, MapBufferRangeWriteInvalidateRangeSucceeds) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   // With MAP_INVALIDATE_RANGE_BIT, no need to append MAP_READ_BIT.
   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
   DoBufferData(kTarget, kSize + kOffset);
 
   std::vector<int8_t> data(kSize);
@@ skipping 12 matching lines @@
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
   memset(mem, 72, kSize);  // Init to a random value other than 0.
 
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
            result_shm_id, result_shm_offset);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeWriteInvalidateBufferSucceeds) {
+TEST_P(GLES2DecoderTest, MapBufferRangeWriteInvalidateBufferSucceeds) {
   // Test INVALIDATE_BUFFER_BIT is mapped to INVALIDATE_RANGE_BIT.
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
   // With MAP_INVALIDATE_BUFFER_BIT, no need to append MAP_READ_BIT.
   const GLbitfield kFilteredAccess =
       GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
@@ skipping 15 matching lines @@
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
   memset(mem, 72, kSize);  // Init to a random value other than 0.
 
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
            result_shm_id, result_shm_offset);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeWriteUnsynchronizedBit) {
+TEST_P(GLES2DecoderTest, MapBufferRangeWriteUnsynchronizedBit) {
   // Test UNSYNCHRONIZED_BIT is filtered out.
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
   DoBufferData(kTarget, kSize + kOffset);
 
@@ skipping 13 matching lines @@
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
   memset(mem, 72, kSize);  // Init to a random value other than 0.
 
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
            result_shm_id, result_shm_offset);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeWithError) {
+TEST_P(GLES2DecoderTest, MapBufferRangeWithError) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_READ_BIT;
   std::vector<int8_t> data(kSize);
   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
     data[ii] = static_cast<int8_t>(ii % 255);
   }
 
   typedef MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = 0;
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
   memset(mem, 72, kSize);  // Init to a random value other than 0.
 
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
            result_shm_id, result_shm_offset);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   memset(&data[0], 72, kSize);
   // Mem is untouched.
   EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
   EXPECT_EQ(0u, *result);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES3DecoderTest, MapBufferRangeBadSharedMemoryFails) {
+TEST_P(GLES2DecoderTest, MapBufferRangeBadSharedMemoryFails) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_READ_BIT;
   std::vector<int8_t> data(kSize);
   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
     data[ii] = static_cast<int8_t>(ii % 255);
   }
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
   DoBufferData(kTarget, kOffset + kSize);
 
   typedef MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = 0;
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 
+  decoder_->set_unsafe_es3_apis_enabled(true);
   MapBufferRange cmd;
   cmd.Init(kTarget, kOffset, kSize, kAccess,
            kInvalidSharedMemoryId, data_shm_offset,
            result_shm_id, result_shm_offset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kTarget, kOffset, kSize, kAccess,
            data_shm_id, data_shm_offset,
            kInvalidSharedMemoryId, result_shm_offset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kTarget, kOffset, kSize, kAccess,
            data_shm_id, kInvalidSharedMemoryOffset,
            result_shm_id, result_shm_offset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kTarget, kOffset, kSize, kAccess,
            data_shm_id, data_shm_offset,
            result_shm_id, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES3DecoderTest, UnmapBufferWriteNotMappedFails) {
+TEST_P(GLES2DecoderTest, UnmapBufferWriteNotMappedFails) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 
   UnmapBuffer cmd;
   cmd.Init(kTarget);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES3DecoderTest, UnmapBufferWriteNoBoundBufferFails) {
+TEST_P(GLES2DecoderTest, UnmapBufferWriteNoBoundBufferFails) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
 
   UnmapBuffer cmd;
   cmd.Init(kTarget);
+  decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES3DecoderTest, BufferDataDestroysDataStore) {
+TEST_P(GLES2DecoderTest, BufferDataDestroysDataStore) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
   DoBufferData(kTarget, kSize + kOffset);
 
   std::vector<int8_t> data(kSize);
 
+  decoder_->set_unsafe_es3_apis_enabled(true);
+
   {  // MapBufferRange succeeds
     EXPECT_CALL(*gl_,
                 MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
         .WillOnce(Return(&data[0]))
         .RetiresOnSaturation();
 
     typedef MapBufferRange::Result Result;
     Result* result = GetSharedMemoryAs<Result*>();
 
     MapBufferRange cmd;
@@ skipping 10 matching lines @@
   }
 
   {  // UnmapBuffer fails.
     UnmapBuffer cmd;
     cmd.Init(kTarget);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   }
 }
 
-TEST_P(GLES3DecoderTest, DeleteBuffersDestroysDataStore) {
+TEST_P(GLES2DecoderTest, DeleteBuffersDestroysDataStore) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
   DoBufferData(kTarget, kSize + kOffset);
 
   std::vector<int8_t> data(kSize);
 
+  decoder_->set_unsafe_es3_apis_enabled(true);
+
   {  // MapBufferRange succeeds
     EXPECT_CALL(*gl_,
                 MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
         .WillOnce(Return(&data[0]))
         .RetiresOnSaturation();
 
     typedef MapBufferRange::Result Result;
     Result* result = GetSharedMemoryAs<Result*>();
 
     MapBufferRange cmd;
@@ skipping 10 matching lines @@
   }
 
   {  // UnmapBuffer fails.
     UnmapBuffer cmd;
     cmd.Init(kTarget);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   }
 }
 
-TEST_P(GLES3DecoderTest, MapUnmapBufferInvalidTarget) {
+TEST_P(GLES2DecoderTest, MapUnmapBufferInvalidTarget) {
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLintptr kOffset = 10;
   const GLsizeiptr kSize = 64;
   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
 
   uint32_t result_shm_id = kSharedMemoryId;
   uint32_t result_shm_offset = kSharedMemoryOffset;
   uint32_t data_shm_id = kSharedMemoryId;
   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 
+  decoder_->set_unsafe_es3_apis_enabled(true);
+
   typedef MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
 
   {
     MapBufferRange cmd;
     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
              result_shm_id, result_shm_offset);
     *result = 0;
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(0u, *result);
@@ skipping 54 matching lines @@
     if (ii >= kWriteOffset && ii < kWriteOffset + kCopySize) {
       EXPECT_EQ(kValue0, shadow_data[ii]);
     } else {
       EXPECT_EQ(kValue1, shadow_data[ii]);
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu