Let DoMapBufferRange write the result integer to signal a GL error.

gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc

 // Copyright (c) 2016 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_passthrough.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
@@ skipping 2716 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoMapBufferRange(
     GLenum target,
     GLintptr offset,
     GLsizeiptr size,
     GLbitfield access,
     void* ptr,
     int32_t data_shm_id,
-    uint32_t data_shm_offset) {
+    uint32_t data_shm_offset,
+    uint32_t* result) {
   FlushErrors();
 
   GLbitfield filtered_access = access;
 
   // Always filter out GL_MAP_UNSYNCHRONIZED_BIT to get rid of undefined
   // behaviors.
   filtered_access = (filtered_access & ~GL_MAP_UNSYNCHRONIZED_BIT);
 
   if ((filtered_access & GL_MAP_INVALIDATE_BUFFER_BIT) != 0) {
     // To be on the safe side, always map GL_MAP_INVALIDATE_BUFFER_BIT to
     // GL_MAP_INVALIDATE_RANGE_BIT.
     filtered_access = (filtered_access & ~GL_MAP_INVALIDATE_BUFFER_BIT);
     filtered_access = (filtered_access | GL_MAP_INVALIDATE_RANGE_BIT);
   }
   if ((filtered_access & GL_MAP_INVALIDATE_RANGE_BIT) == 0) {
     // If this user intends to use this buffer without invalidating the data, we
     // need to also add GL_MAP_READ_BIT to preserve the original data when
     // copying it to shared memory.
     filtered_access = (filtered_access | GL_MAP_READ_BIT);
   }
 
   void* mapped_ptr = glMapBufferRange(target, offset, size, filtered_access);
   if (FlushErrors() || mapped_ptr == nullptr) {
     // Had an error while mapping, don't copy any data
+    *result = 0;
     return error::kNoError;
   }
 
   if ((filtered_access & GL_MAP_INVALIDATE_RANGE_BIT) == 0) {
     memcpy(ptr, mapped_ptr, size);
   }
 
   // Track the mapping of this buffer so that data can be synchronized when it
   // is unmapped
   DCHECK(bound_buffers_.find(target) != bound_buffers_.end());
   GLuint client_buffer = bound_buffers_.at(target);
 
   MappedBuffer mapped_buffer_info;
   mapped_buffer_info.size = size;
   mapped_buffer_info.access = filtered_access;
   mapped_buffer_info.map_ptr = static_cast<uint8_t*>(mapped_ptr);
   mapped_buffer_info.data_shm_id = data_shm_id;
   mapped_buffer_info.data_shm_offset = data_shm_offset;
 
   DCHECK(resources_->mapped_buffer_map.find(client_buffer) ==
          resources_->mapped_buffer_map.end());
   resources_->mapped_buffer_map.insert(
       std::make_pair(client_buffer, mapped_buffer_info));
 
+  *result = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUnmapBuffer(GLenum target) {
   auto bound_buffers_iter = bound_buffers_.find(target);
   if (bound_buffers_iter == bound_buffers_.end() ||
       bound_buffers_iter->second == 0) {
     InsertError(GL_INVALID_OPERATION, "No buffer bound to this target.");
     return error::kNoError;
   }
@@ skipping 1173 matching lines @@
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSetEnableDCLayersCHROMIUM(
     GLboolean enable) {
   NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 }  // namespace gles2
 }  // namespace gpu