Revert of Initialize buffers before allowing access to them.

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 5331 matching lines @@
                            "id not generated by glGenBuffers");
         return;
       }
 
       // It's a new id so make a buffer for it.
       glGenBuffersARB(1, &service_id);
       CreateBuffer(client_id, service_id);
       buffer = GetBuffer(client_id);
       DCHECK(buffer);
     }
-    if (!buffer_manager()->SetTarget(buffer, target)) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
-                         "buffer bound to more than 1 target");
-      return;
-    }
     service_id = buffer->service_id();
   }
   LogClientServiceForInfo(buffer, client_id, function_name);
 
   scoped_refptr<IndexedBufferBindingHost> bindings;
   switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER:
       bindings = state_.bound_transform_feedback.get();
       break;
     case GL_UNIFORM_BUFFER:
@@ skipping 426 matching lines @@
       return;
     }
     if (buffer->GetMappedRange()) {
       std::string msg = base::StringPrintf(
           "bound buffer bound at index %i is mapped", static_cast<int>(ii));
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name, msg.c_str());
       return;
     }
   }
   transform_feedback->DoBeginTransformFeedback(primitive_mode);
-  DCHECK(transform_feedback->active());
 }
 
 void GLES2DecoderImpl::DoEndTransformFeedback() {
   const char* function_name = "glEndTransformFeedback";
   DCHECK(state_.bound_transform_feedback.get());
   if (!state_.bound_transform_feedback->active()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "transform feedback is not active");
     return;
   }
@@ skipping 3697 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name,
         "Source and destination textures of the draw are the same.");
     return false;
   }
 
   return state_.vertex_attrib_manager
       ->ValidateBindings(function_name,
                          this,
                          feature_info_.get(),
-                         buffer_manager(),
                          state_.current_program.get(),
                          max_vertex_accessed,
                          instanced,
                          primcount);
 }
 
 bool GLES2DecoderImpl::SimulateAttrib0(
     const char* function_name, GLuint max_vertex_accessed, bool* simulated) {
   DCHECK(simulated);
   *simulated = false;
@@ skipping 301 matching lines @@
     LOCAL_RENDER_WARNING("Render count or primcount is 0.");
     return error::kNoError;
   }
 
   if (feature_info_->IsWebGL2OrES3Context()) {
     if (!AttribsTypeMatch()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "vertexAttrib function must match shader attrib type");
       return error::kNoError;
     }
+    if (state_.bound_array_buffer.get() &&
+        state_.bound_array_buffer->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ARRAY_BUFFER is mapped");
+      return error::kNoError;
+    }
   }
 
   base::CheckedNumeric<GLuint> checked_max_vertex = first;
   checked_max_vertex += count - 1;
   // first and count-1 are both a non-negative int, so their sum fits an
   // unsigned int.
-  if (!checked_max_vertex.IsValid()) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
-                       "first + count overflow");
-    return error::kNoError;
-  }
-  GLuint max_vertex_accessed = checked_max_vertex.ValueOrDefault(0);
+  GLuint max_vertex_accessed = checked_max_vertex.ValueOrDie();
   if (IsDrawValid(function_name, max_vertex_accessed, instanced, primcount)) {
     if (!ClearUnclearedTextures()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
     bool simulated_attrib_0 = false;
     if (!SimulateAttrib0(
         function_name, max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
@@ skipping 64 matching lines @@
 error::Error GLES2DecoderImpl::DoDrawElements(const char* function_name,
                                               bool instanced,
                                               GLenum mode,
                                               GLsizei count,
                                               GLenum type,
                                               int32_t offset,
                                               GLsizei primcount) {
   error::Error error = WillAccessBoundFramebufferForDraw();
   if (error != error::kNoError)
     return error;
+  if (!state_.vertex_attrib_manager->element_array_buffer()) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_OPERATION, function_name, "No element array buffer bound");
+    return error::kNoError;
+  }
 
   if (count < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "offset < 0");
     return error::kNoError;
   }
   if (!validators_->draw_mode.IsValid(mode)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, mode, "mode");
     return error::kNoError;
   }
   if (!validators_->index_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, type, "type");
     return error::kNoError;
   }
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
-  Buffer* element_array_buffer = buffer_manager()->RequestBufferAccess(
-      &state_, GL_ELEMENT_ARRAY_BUFFER, function_name);
-  if (!element_array_buffer) {
-    return error::kNoError;
-  }
 
   if (!CheckBoundDrawFramebufferValid(function_name)) {
     return error::kNoError;
   }
 
   if (state_.bound_transform_feedback.get() &&
       state_.bound_transform_feedback->active() &&
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
         "transformfeedback is active and not paused");
     return error::kNoError;
   }
 
   if (count == 0 || primcount == 0) {
     return error::kNoError;
   }
 
   if (feature_info_->IsWebGL2OrES3Context()) {
     if (!AttribsTypeMatch()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "vertexAttrib function must match shader attrib type");
       return error::kNoError;
     }
+    if (state_.bound_array_buffer.get() &&
+        state_.bound_array_buffer->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ARRAY_BUFFER is mapped");
+      return error::kNoError;
+    }
+    if (state_.vertex_attrib_manager->element_array_buffer() &&
+        state_.vertex_attrib_manager->element_array_buffer()
+            ->GetMappedRange()) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "bound ELEMENT_ARRAY_BUFFER is mapped");
+      return error::kNoError;
+    }
   }
 
   GLuint max_vertex_accessed;
+  Buffer* element_array_buffer =
+      state_.vertex_attrib_manager->element_array_buffer();
+
   if (!element_array_buffer->GetMaxValueForRange(
           offset, count, type,
           state_.enable_flags.primitive_restart_fixed_index,
           &max_vertex_accessed)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(function_name, max_vertex_accessed, instanced, primcount)) {
@@ skipping 1074 matching lines @@
           WriteAlphaData<uint16_t>(pixels, height, channel_count, alpha_channel,
                                    unpadded_row_size, padded_row_size, 0x3C00);
           break;
       }
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(uint32_t immediate_data_size,
                                                 const volatile void* cmd_data) {
-  const char* func_name = "glReadPixels";
   const volatile gles2::cmds::ReadPixels& c =
       *static_cast<const volatile gles2::cmds::ReadPixels*>(cmd_data);
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleReadPixels");
   error::Error fbo_error = WillAccessBoundFramebufferForRead();
   if (fbo_error != error::kNoError)
     return fbo_error;
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   uint32_t pixels_shm_id = c.pixels_shm_id;
   uint32_t pixels_shm_offset = c.pixels_shm_offset;
   uint32_t result_shm_id = c.result_shm_id;
   uint32_t result_shm_offset = c.result_shm_offset;
   GLboolean async = static_cast<GLboolean>(c.async);
   if (width < 0 || height < 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "dimensions < 0");
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
   typedef cmds::ReadPixels::Result Result;
 
   PixelStoreParams params;
   if (pixels_shm_id == 0) {
     params = state_.GetPackParams();
   } else {
     // When reading into client buffer, we actually set pack parameters to 0
     // (except for alignment) before calling glReadPixels. This makes sure we
@@ skipping 14 matching lines @@
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            &padding)) {
     return error::kOutOfBounds;
   }
 
   uint8_t* pixels = nullptr;
   Buffer* buffer = state_.bound_pixel_pack_buffer.get();
   if (pixels_shm_id == 0) {
-    if (!buffer) {
+    if (buffer) {
+      if (buffer->GetMappedRange()) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
+            "pixel pack buffer should not be mapped to client memory");
+        return error::kNoError;
+      }
+      uint32_t size = 0;
+      if (!SafeAddUint32(pixels_size + skip_size, pixels_shm_offset, &size)) {
+        LOCAL_SET_GL_ERROR(
+            GL_INVALID_VALUE, "glReadPixels", "size + offset overflow");
+        return error::kNoError;
+      }
+      if (static_cast<uint32_t>(buffer->size()) < size) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
+            "pixel pack buffer is not large enough");
+        return error::kNoError;
+      }
+      pixels = reinterpret_cast<uint8_t *>(pixels_shm_offset);
+      pixels += skip_size;
+    } else {
       return error::kInvalidArguments;
     }
-    if (!buffer_manager()->RequestBufferAccess(
-            state_.GetErrorState(), buffer, func_name, "pixel pack buffer")) {
-      return error::kNoError;
-    }
-    uint32_t size = 0;
-    if (!SafeAddUint32(pixels_size + skip_size, pixels_shm_offset, &size)) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "size + offset overflow");
-      return error::kNoError;
-    }
-    if (static_cast<uint32_t>(buffer->size()) < size) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
-                         "pixel pack buffer is not large enough");
-      return error::kNoError;
-    }
-    pixels = reinterpret_cast<uint8_t *>(pixels_shm_offset);
-    pixels += skip_size;
   } else {
     if (buffer) {
       return error::kInvalidArguments;
-    }
-    DCHECK_EQ(0u, skip_size);
-    pixels = GetSharedMemoryAs<uint8_t*>(
-        pixels_shm_id, pixels_shm_offset, pixels_size);
-    if (!pixels) {
-      return error::kOutOfBounds;
+    } else {
+      DCHECK_EQ(0u, skip_size);
+      pixels = GetSharedMemoryAs<uint8_t*>(
+          pixels_shm_id, pixels_shm_offset, pixels_size);
+      if (!pixels) {
+        return error::kOutOfBounds;
+      }
     }
   }
 
   Result* result = nullptr;
   if (result_shm_id != 0) {
     result = GetSharedMemoryAs<Result*>(
         result_shm_id, result_shm_offset, sizeof(*result));
     if (!result) {
       return error::kOutOfBounds;
     }
     if (result->success != 0) {
       return error::kInvalidArguments;
     }
   }
 
   if (!validators_->read_pixel_format.IsValid(format)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, format, "format");
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadPixels", format, "format");
     return error::kNoError;
   }
   if (!validators_->read_pixel_type.IsValid(type)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, type, "type");
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadPixels", type, "type");
     return error::kNoError;
   }
 
-  if (!CheckBoundReadFramebufferValid(
-          func_name, GL_INVALID_FRAMEBUFFER_OPERATION)) {
+  if (!CheckBoundReadFramebufferValid("glReadPixels",
+                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return error::kNoError;
   }
   GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   if (src_internal_format == 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "no valid color image");
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
+        "no valid color image");
     return error::kNoError;
   }
   std::vector<GLenum> accepted_formats;
   std::vector<GLenum> accepted_types;
   switch (src_internal_format) {
     case GL_R8UI:
     case GL_R16UI:
     case GL_R32UI:
     case GL_RG8UI:
     case GL_RG16UI:
@@ skipping 61 matching lines @@
     GLint preferred_format = 0;
     DoGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &preferred_format, 1);
     GLint preferred_type = 0;
     DoGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &preferred_type, 1);
     if (format == static_cast<GLenum>(preferred_format) &&
         type == static_cast<GLenum>(preferred_type)) {
       format_type_acceptable = true;
     }
   }
   if (!format_type_acceptable) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
         "format and type incompatible with the current read framebuffer");
     return error::kNoError;
   }
   if (type == GL_HALF_FLOAT_OES && !gl_version_info().is_es) {
     type = GL_HALF_FLOAT;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFramebufferSize();
 
   int32_t max_x;
   int32_t max_y;
   if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y)) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "dimensions out of range");
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
     return error::kNoError;
   }
 
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
+  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glReadPixels");
 
   ScopedResolvedFramebufferBinder binder(this, false, true);
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
 
   gfx::Rect rect(x, y, width, height);  // Safe before we checked above.
   gfx::Rect max_rect(max_size);
   if (!max_rect.Contains(rect)) {
     rect.Intersect(max_rect);
     if (!rect.IsEmpty()) {
       if (y < 0) {
@@ skipping 82 matching lines @@
         glReadPixels(x, max_y - 1, width, 1, format, type, pixels);
         glPixelStorei(GL_PACK_ALIGNMENT, state_.pack_alignment);
       } else {
         glReadPixels(x, y, width, height, format, type, pixels);
       }
     } else {
       glReadPixels(x, y, width, height, format, type, pixels);
     }
   }
   if (pixels_shm_id != 0) {
-    GLenum error = LOCAL_PEEK_GL_ERROR(func_name);
+    GLenum error = LOCAL_PEEK_GL_ERROR("glReadPixels");
     if (error == GL_NO_ERROR) {
       if (result) {
         result->success = 1;
         result->row_length = static_cast<uint32_t>(rect.width());
         result->num_rows = static_cast<uint32_t>(rect.height());
       }
       FinishReadPixels(width, height, format, type, pixels_shm_id,
                        pixels_shm_offset, result_shm_id, result_shm_offset,
                        state_.pack_alignment, read_format, 0);
     }
@@ skipping 1390 matching lines @@
     if (state_.bound_pixel_unpack_buffer->GetMappedRange() != nullptr) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "pixel unpack buffer is mapped");
       return false;
     }
 
     base::CheckedNumeric<GLintptr> pbo_bytes_required(
         reinterpret_cast<GLintptr>(data));
     pbo_bytes_required += bytes_required;
     if (!pbo_bytes_required.IsValid() ||
-        pbo_bytes_required.ValueOrDefault(0) >
+        pbo_bytes_required.ValueOrDie() >
             state_.bound_pixel_unpack_buffer->size()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "pixel unpack buffer is not large enough");
       return false;
     }
   }
 
   return true;
 }
 
@@ skipping 4408 matching lines @@
         break;
     }
   } else {
     glGetInternalformativ(target, format, pname, num_values, params);
   }
   result->SetNumResults(num_values);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleMapBufferRange(
-    uint32_t immediate_data_size, const volatile void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled()) {
     return error::kUnknownCommand;
   }
 
   const char* func_name = "glMapBufferRange";
   const volatile gles2::cmds::MapBufferRange& c =
       *static_cast<const volatile gles2::cmds::MapBufferRange*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLbitfield access = static_cast<GLbitfield>(c.access);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
   uint32_t data_shm_offset = static_cast<uint32_t>(c.data_shm_offset);
 
   typedef cmds::MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   if (*result != 0) {
     *result = 0;
     return error::kInvalidArguments;
   }
   if (!validators_->buffer_target.IsValid(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, func_name, "no buffer bound to target");
+    return error::kNoError;
+  }
+  if (buffer->GetMappedRange()) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_OPERATION, func_name, "buffer is already mapped");
+    return error::kNoError;
+  }
   if (size == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "size is zero");
     return error::kNoError;
   }
-  Buffer* buffer = buffer_manager()->RequestBufferAccess(
-      &state_, target, offset, size, func_name);
-  if (!buffer) {
+  if (!buffer->CheckRange(offset, size)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid range");
     return error::kNoError;
   }
-  if (state_.bound_transform_feedback->active() &&
-      !state_.bound_transform_feedback->paused()) {
-    size_t used_binding_count =
-        state_.current_program->effective_transform_feedback_varyings().size();
-    if (state_.bound_transform_feedback->UsesBuffer(
-            used_binding_count, buffer)) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
-                         "active transform feedback is using this buffer");
-      return error::kNoError;
-    }
-  }
-
   int8_t* mem =
       GetSharedMemoryAs<int8_t*>(data_shm_id, data_shm_offset, size);
   if (!mem) {
     return error::kOutOfBounds;
   }
   if (AnyOtherBitsSet(access, (GL_MAP_READ_BIT |
                                GL_MAP_WRITE_BIT |
                                GL_MAP_INVALIDATE_RANGE_BIT |
                                GL_MAP_INVALIDATE_BUFFER_BIT |
                                GL_MAP_FLUSH_EXPLICIT_BIT |
@@ skipping 13 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "Incompatible access bits with MAP_READ_BIT");
     return error::kNoError;
   }
   if (AllBitsSet(access, GL_MAP_FLUSH_EXPLICIT_BIT) &&
       !AllBitsSet(access, GL_MAP_WRITE_BIT)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "MAP_FLUSH_EXPLICIT_BIT set without MAP_WRITE_BIT");
     return error::kNoError;
   }
+  if (target == GL_TRANSFORM_FEEDBACK_BUFFER &&
+      state_.bound_transform_feedback->active()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+                       "transform feedback is active");
+    return error::kNoError;
+  }
   if (AllBitsSet(access, GL_MAP_INVALIDATE_BUFFER_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);
   }
   // Always filter out GL_MAP_UNSYNCHRONIZED_BIT to get rid of undefined
   // behaviors.
   access = (access & ~GL_MAP_UNSYNCHRONIZED_BIT);
   if (AllBitsSet(access, GL_MAP_WRITE_BIT) &&
@@ skipping 43 matching lines @@
   if (!AllBitsSet(mapped_range->access, GL_MAP_WRITE_BIT) ||
       AllBitsSet(mapped_range->access, 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();
     DCHECK(mem);
     DCHECK(mapped_range->pointer);
     memcpy(mapped_range->pointer, mem, mapped_range->size);
     if (buffer->shadowed()) {
-      buffer->SetRange(mapped_range->offset, mapped_range->size, mem);
+      bool success = buffer->SetRange(
+          mapped_range->offset, mapped_range->size, mem);
+      DCHECK(success);
     }
   }
   buffer->RemoveMappedRange();
   GLboolean rt = glUnmapBuffer(target);
   if (rt == GL_FALSE) {
     // At this point, we have already done the necessary validation, so
     // GL_FALSE indicates data corruption.
     // TODO(zmo): We could redo the map / copy data / unmap to recover, but
     // the second unmap could still return GL_FALSE. For now, we simply lose
     // the contexts in the share group.
@@ skipping 36 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name,
         "offset + size out of bounds");
     return;
   }
   char* client_data = reinterpret_cast<char*>(mapped_range->GetShmPointer());
   DCHECK(client_data);
   char* gpu_data = reinterpret_cast<char*>(mapped_range->pointer);
   DCHECK(gpu_data);
   memcpy(gpu_data + offset, client_data + offset, size);
   if (buffer->shadowed()) {
-    buffer->SetRange(mapped_range->offset + offset, size, client_data + offset);
+    bool success = buffer->SetRange(
+        mapped_range->offset + offset, size, client_data + offset);
+    DCHECK(success);
   }
   glFlushMappedBufferRange(target, offset, size);
 }
 
 // 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();
@@ skipping 366 matching lines @@
           num_coords_expected += 5;
           break;
         default:
           LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, kFunctionName, "invalid command");
           return error::kNoError;
       }
     }
   }
 
   if (!num_coords_expected.IsValid() ||
-      num_coords != num_coords_expected.ValueOrDefault(0)) {
+      num_coords != num_coords_expected.ValueOrDie()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "numCoords does not match commands");
     return error::kNoError;
   }
 
   const void* coords = NULL;
 
   if (num_coords > 0) {
     uint32_t coords_size = 0;
     uint32_t coord_type_size =
@@ skipping 797 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