Minor improvement in uniform block backing buffer validation.

gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 29 matching lines @@
       max_buffer_size_(kDefaultMaxBufferSize),
       allow_buffers_on_multiple_targets_(false),
       allow_fixed_attribs_(false),
       buffer_count_(0),
       primitive_restart_fixed_index_(0),
       lost_context_(false),
       use_client_side_arrays_for_stream_buffers_(
           feature_info
               ? feature_info->workarounds()
                     .use_client_side_arrays_for_stream_buffers
-              : 0),
-      mapped_buffer_count_(0) {
+              : 0) {
   // When created from InProcessCommandBuffer, we won't have a |memory_tracker_|
   // so don't register a dump provider.
   if (memory_tracker_) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "gpu::BufferManager", base::ThreadTaskRunnerHandle::Get());
   }
 }
 
 BufferManager::~BufferManager() {
   DCHECK(buffers_.empty());
@@ skipping 270 matching lines @@
   range_set_.insert(std::make_pair(range, max_v));
   *max_value = max_v;
   return true;
 }
 
 void Buffer::SetMappedRange(GLintptr offset, GLsizeiptr size, GLenum access,
                             void* pointer, scoped_refptr<gpu::Buffer> shm,
                             unsigned int shm_offset) {
   mapped_range_.reset(
       new MappedRange(offset, size, access, pointer, shm, shm_offset));
-  manager_->IncreaseMappedBufferCount();
 }
 
 void Buffer::RemoveMappedRange() {
-  if (mapped_range_.get())
-    manager_->DecreaseMappedBufferCount();
   mapped_range_.reset(nullptr);
 }
 
 bool BufferManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (BufferMap::const_iterator it = buffers_.begin();
        it != buffers_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
@@ skipping 448 matching lines @@
 bool BufferManager::RequestBuffersAccess(
     ErrorState* error_state,
     const IndexedBufferBindingHost* bindings,
     const std::vector<GLsizeiptr>& variable_sizes,
     GLsizei count,
     const char* func_name,
     const char* message_tag) {
   DCHECK(error_state);
   DCHECK(bindings);
   for (size_t ii = 0; ii < variable_sizes.size(); ++ii) {
+    if (variable_sizes[ii] == 0)
+      continue;
     Buffer* buffer = bindings->GetBufferBinding(ii);
     if (!buffer) {
       std::string msg = base::StringPrintf(
           "%s : no buffer bound at index %zu", message_tag, ii);
       ERRORSTATE_SET_GL_ERROR(
           error_state, GL_INVALID_OPERATION, func_name, msg.c_str());
       return false;
     }
     if (buffer->GetMappedRange()) {
       std::string msg = base::StringPrintf(
@@ skipping 11 matching lines @@
           "%s : buffer or buffer range not large enough at index %zu",
           message_tag, ii);
       ERRORSTATE_SET_GL_ERROR(
           error_state, GL_INVALID_OPERATION, func_name, msg.c_str());
       return false;
     }
   }
   return true;
 }
 
-void BufferManager::IncreaseMappedBufferCount() {
-  DCHECK_GT(std::numeric_limits<uint32_t>::max(), mapped_buffer_count_);
-  mapped_buffer_count_++;
-}
-
-void BufferManager::DecreaseMappedBufferCount() {
-  DCHECK_LT(0u, mapped_buffer_count_);
-  mapped_buffer_count_--;
-}
-
 bool BufferManager::RequestBufferAccessV(ErrorState* error_state,
                                          Buffer* buffer,
                                          const char* func_name,
                                          const char* error_message_format,
                                          va_list varargs) {
   DCHECK(error_state);
 
   if (!buffer || buffer->IsDeleted()) {
     std::string message_tag = base::StringPrintV(error_message_format, varargs);
     std::string msg = base::StringPrintf("%s : no buffer", message_tag.c_str());
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
                             msg.c_str());
     return false;
   }
   if (buffer->GetMappedRange()) {
     std::string message_tag = base::StringPrintV(error_message_format, varargs);
     std::string msg = base::StringPrintf("%s : buffer is mapped",
                                          message_tag.c_str());
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
                             msg.c_str());
     return false;
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu