Update shadowed data in MapBufferRange path.

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 111 matching lines @@
     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(GLES2DecoderTest, MapBufferRangeUnmapBufferWriteSucceeds) {
-  const GLenum kTarget = GL_ARRAY_BUFFER;
+  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;
   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 
+  typedef MapBufferRange::Result Result;
+  Result* result = GetSharedMemoryAs<Result*>();
+  int8_t* client_data = GetSharedMemoryAs<int8_t*>() + sizeof(uint32_t);
+
   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
-  DoBufferData(kTarget, kSize + kOffset);
+  Buffer* buffer = GetBuffer(client_buffer_id_);
+  EXPECT_TRUE(buffer != nullptr);
+  DoBufferData(kTarget, kTotalSize);
+  std::vector<int8_t> gpu_data(kTotalSize);
+  for (GLsizeiptr ii = 0; ii < kTotalSize; ++ii) {
+    gpu_data[ii] = static_cast<int8_t>(ii % 128);
+  }
+  DoBufferSubData(kTarget, 0, kTotalSize, &gpu_data[0]);
 
-  std::vector<int8_t> data(kSize);
-  for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
-    data[ii] = static_cast<int8_t>(ii % 255);
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_TRUE(buffer->shadowed());
+  const int8_t* shadow_data = reinterpret_cast<const int8_t*>(
+      buffer->GetRange(0, kTotalSize));
+  EXPECT_TRUE(shadow_data);
+  // Verify the shadow data is initialized.
+  for (GLsizeiptr ii = 0; ii < kTotalSize; ++ii) {
+    EXPECT_EQ(static_cast<int8_t>(ii % 128), shadow_data[ii]);
   }
 
   {  // MapBufferRange succeeds
     EXPECT_CALL(*gl_,
                 MapBufferRange(kTarget, kOffset, kSize, kMappedAccess))
-        .WillOnce(Return(&data[0]))
+        .WillOnce(Return(&gpu_data[kOffset]))
         .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);
+    // Verify the buffer range from GPU is copied to client mem.
+    EXPECT_EQ(0, memcmp(&gpu_data[kOffset], client_data, kSize));
   }
 
-  { // UnmapBuffer succeeds
+  // 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]);
+      }
+    }
   }
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 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;
@@ skipping 404 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