Implementing FlushMappedBufferRange in GPU command buffer.

gpu/command_buffer/service/gles2_cmd_decoder.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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 1083 matching lines @@
 
   void DoLoseContextCHROMIUM(GLenum current, GLenum other);
 
   void DoFlushDriverCachesCHROMIUM(void);
 
   void DoMatrixLoadfCHROMIUM(GLenum matrix_mode, const GLfloat* matrix);
   void DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode);
   void DoScheduleCALayerInUseQueryCHROMIUM(GLsizei count,
                                            const GLuint* textures);
 
+  void DoFlushMappedBufferRange(
+      GLenum target, GLintptr offset, GLsizeiptr size);
+
   // Creates a Program for the given program.
   Program* CreateProgram(GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
     return program_manager()->GetProgram(client_id);
   }
 
@@ skipping 15344 matching lines @@
     return error::kOutOfBounds;
   }
 
   if (!validators_->buffer_target.IsValid(target)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glMapBufferRange", target, "target");
     return error::kNoError;
   }
 
   GLbitfield mask = GL_MAP_INVALIDATE_BUFFER_BIT;
   if ((access & mask) == mask) {
-    // TODO(zmo): To be on the safe side, always map
-    // GL_MAP_INVALIDATE_BUFFER_BIT to GL_MAP_INVALIDATE_RANGE_BIT.
+    // To be on the safe side, always map GL_MAP_INVALIDATE_BUFFER_BIT to
+    // GL_MAP_INVALIDATE_RANGE_BIT.
     access = (access & ~GL_MAP_INVALIDATE_BUFFER_BIT);
     access = (access | GL_MAP_INVALIDATE_RANGE_BIT);
   }
-  // TODO(zmo): Always filter out GL_MAP_UNSYNCHRONIZED_BIT to get rid of
-  // undefined behaviors.
+  // Always filter out GL_MAP_UNSYNCHRONIZED_BIT to get rid of undefined
+  // behaviors.
   mask = GL_MAP_READ_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
   if ((access & mask) == mask) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "MapBufferRange",
                        "incompatible access bits");
     return error::kNoError;
   }
   access = (access & ~GL_MAP_UNSYNCHRONIZED_BIT);
   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT &&
       (access & GL_MAP_INVALIDATE_RANGE_BIT) == 0) {
     access = (access | GL_MAP_READ_BIT);
   }
   void* ptr = glMapBufferRange(target, offset, size, access);
   if (ptr == nullptr) {
     return error::kNoError;
   }
   Buffer* buffer = buffer_manager()->GetBufferInfoForTarget(&state_, target);
   DCHECK(buffer);
   buffer->SetMappedRange(offset, size, access, ptr,
                          GetSharedMemoryBuffer(data_shm_id));
   if ((access & GL_MAP_INVALIDATE_RANGE_BIT) == 0) {
     memcpy(mem, ptr, size);
   }
   *result = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleUnmapBuffer(
     uint32_t immediate_data_size, const void* cmd_data) {
+  const char* func_name = "glUnmapBuffer";
   if (!unsafe_es3_apis_enabled()) {
     return error::kUnknownCommand;
   }
   const gles2::cmds::UnmapBuffer& c =
       *static_cast<const gles2::cmds::UnmapBuffer*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
 
   if (!validators_->buffer_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM("glMapBufferRange", target, "target");
+    LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, target, "target");
     return error::kNoError;
   }
 
   Buffer* buffer = buffer_manager()->GetBufferInfoForTarget(&state_, target);
   if (!buffer) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "UnmapBuffer", "no buffer bound");
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "no buffer bound");
     return error::kNoError;
   }
   const Buffer::MappedRange* mapped_range = buffer->GetMappedRange();
   if (!mapped_range) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "UnmapBuffer",
-                       "buffer is unmapped");
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "buffer is unmapped");
     return error::kNoError;
   }
   if ((mapped_range->access & GL_MAP_WRITE_BIT) == 0 ||
       (mapped_range->access & GL_MAP_FLUSH_EXPLICIT_BIT) ==
            GL_MAP_FLUSH_EXPLICIT_BIT) {
     // If we don't need to write back, or explict flush is required, no copying
     // back is needed.
   } else {
     void* mem = mapped_range->GetShmPointer();
     if (!mem) {
@@ skipping 12 matching lines @@
     // the contexts in the share group.
     LOG(ERROR) << "glUnmapBuffer unexpectedly returned GL_FALSE";
     // Need to lose current context before broadcasting!
     MarkContextLost(error::kGuilty);
     group_->LoseContexts(error::kInnocent);
     return error::kLostContext;
   }
   return error::kNoError;
 }
 
+void GLES2DecoderImpl::DoFlushMappedBufferRange(
+    GLenum target, GLintptr offset, GLsizeiptr size) {
+  const char* func_name = "glFlushMappedBufferRange";
+  if (offset < 0) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "offset < 0");
+    return;
+  }
+  Buffer* buffer = buffer_manager()->GetBufferInfoForTarget(&state_, target);
+  if (!buffer) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "no buffer bound");
+    return;
+  }
+  const Buffer::MappedRange* mapped_range = buffer->GetMappedRange();
+  if (!mapped_range) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "buffer is unmapped");
+    return;
+  }
+  if ((mapped_range->access & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+        "buffer is mapped without MAP_FLUSH_EXPLICIT_BIT flag");
+    return;
+  }
+  base::CheckedNumeric<GLsizeiptr> range_size = size;
+  range_size += offset;
+  if (!range_size.IsValid() ||
+      range_size.ValueOrDefault(0) > mapped_range->size) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name,
+        "offset + size out-of-bounds");
+    return;
+  }
+  glFlushMappedBufferRange(target, offset, size);

[piman, 2016/08/08 22:55:22]

This in itself won't do anything - the client side wrote the data into the
shared memory, but we need to copy the shared memory into the mapped GL buffer
before doing the flush.

Separately, we also should do the maintenance of the buffer's range cache /
shadow buffer if appropriate (see also crbug.com/491002). Actually, that's also
true of UnmapBuffer if GL_MAP_FLUSH_EXPLICIT_BIT is not set.

+}
+
 // Note that GL_LOST_CONTEXT is specific to GLES.
 // For desktop GL we have to query the reset status proactively.
 void GLES2DecoderImpl::OnContextLostError() {
   if (!WasContextLost()) {
     // Need to lose current context before broadcasting!
     CheckResetStatus();
     group_->LoseContexts(error::kUnknown);
     reset_by_robustness_extension_ = true;
   }
 }
@@ skipping 1159 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu