Initialize buffers before allowing access to them.

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) {
+              : 0),
+      mapped_buffer_count_(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 74 matching lines @@
       usage_(GL_STATIC_DRAW) {
   manager_->StartTracking(this);
 }
 
 Buffer::~Buffer() {
   if (manager_) {
     if (!manager_->lost_context_) {
       GLuint id = service_id();
       glDeleteBuffersARB(1, &id);
     }
+    RemoveMappedRange();
     manager_->StopTracking(this);
-    manager_ = NULL;
+    manager_ = nullptr;
   }
 }
 
 const GLvoid* Buffer::StageShadow(bool use_shadow,
                                   GLsizeiptr size,
                                   const GLvoid* data) {
   shadow_.clear();
   if (use_shadow) {
     if (data) {
       shadow_.insert(shadow_.begin(),
                      static_cast<const uint8_t*>(data),
                      static_cast<const uint8_t*>(data) + size);
     } else {
       shadow_.resize(size);
+      memset(shadow_.data(), 0, static_cast<size_t>(size));
     }
     return shadow_.data();
   } else {
     return data;
   }
 }
 
 void Buffer::SetInfo(GLsizeiptr size,
                      GLenum usage,
                      bool use_shadow,
@@ skipping 12 matching lines @@
 bool Buffer::CheckRange(GLintptr offset, GLsizeiptr size) const {
   if (offset < 0 || offset > std::numeric_limits<int32_t>::max() ||
       size < 0 || size > std::numeric_limits<int32_t>::max()) {
     return false;
   }
   base::CheckedNumeric<int32_t> max = offset;
   max += size;
   return max.IsValid() && max.ValueOrDefault(0) <= size_;
 }
 
-bool Buffer::SetRange(GLintptr offset, GLsizeiptr size, const GLvoid * data) {
-  if (!CheckRange(offset, size)) {
-    return false;
-  }
+void Buffer::SetRange(GLintptr offset, GLsizeiptr size, const GLvoid * data) {
+  DCHECK(CheckRange(offset, size));
   if (!shadow_.empty()) {
     DCHECK_LE(static_cast<size_t>(offset + size), shadow_.size());
     memcpy(shadow_.data() + offset, data, size);
     ClearCache();
   }
-  return true;
 }
 
 const void* Buffer::GetRange(GLintptr offset, GLsizeiptr size) const {
   if (shadow_.empty()) {
     return NULL;
   }
   if (!CheckRange(offset, size)) {
     return NULL;
   }
   DCHECK_LE(static_cast<size_t>(offset + size), shadow_.size());
@@ skipping 114 matching lines @@
       break;
     default:
       NOTREACHED();  // should never get here by validation.
       break;
   }
   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;
     }
   }
   return false;
@@ skipping 89 matching lines @@
     GLenum usage,
     const GLvoid* data) {
   // Stage the shadow buffer first if we are using a shadow buffer so that we
   // validate what we store internally.
   const bool use_shadow = UseShadowBuffer(buffer->initial_target(), usage);
   data = buffer->StageShadow(use_shadow, size, data);
 
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glBufferData");
   if (IsUsageClientSideArray(usage)) {
     GLsizei empty_size = UseNonZeroSizeForClientSideArrayBuffer() ? 1 : 0;
-    glBufferData(target, empty_size, NULL, usage);
+    glBufferData(target, empty_size, nullptr, usage);
   } else {
-    glBufferData(target, size, data, usage);
+    if (data || !size) {
+      glBufferData(target, size, data, usage);
+    } else {
+      std::unique_ptr<char[]> zero(new char[size]);
+      memset(zero.get(), 0, size);
+      glBufferData(target, size, zero.get(), usage);
+    }
   }
   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glBufferData");
   if (error != GL_NO_ERROR) {
+    DCHECK_EQ(static_cast<GLenum>(GL_OUT_OF_MEMORY), error);
     size = 0;
+    // TODO(zmo): This doesn't seem correct. There might be shadow data from
+    // a previous successful BufferData() call.
     buffer->StageShadow(false, 0, nullptr);  // Also clear the shadow.
+    return;
   }
 
   SetInfo(buffer, target, size, usage, use_shadow);
 }
 
 void BufferManager::ValidateAndDoBufferSubData(
   ContextState* context_state, GLenum target, GLintptr offset, GLsizeiptr size,
   const GLvoid * data) {
-  const char* func_name = "glBufferSubData";
-
-  ErrorState* error_state = context_state->GetErrorState();
-  Buffer* buffer = GetBufferInfoForTarget(context_state, target);
+  Buffer* buffer = RequestBufferAccess(
+      context_state, target, offset, size, "glBufferSubData");
   if (!buffer) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, func_name,
-        "unknown buffer");
     return;
   }
-
-  if (buffer->GetMappedRange()) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
-        "buffer is mapped");
-    return;
-  }
-
-  DoBufferSubData(error_state, buffer, target, offset, size, data);
+  DoBufferSubData(buffer, target, offset, size, data);
 }
 
 void BufferManager::DoBufferSubData(
-    ErrorState* error_state,
-    Buffer* buffer,
-    GLenum target,
-    GLintptr offset,
-    GLsizeiptr size,
+    Buffer* buffer, GLenum target, GLintptr offset, GLsizeiptr size,
     const GLvoid* data) {
-  if (!buffer->SetRange(offset, size, data)) {
-    ERRORSTATE_SET_GL_ERROR(
-        error_state, GL_INVALID_VALUE, "glBufferSubData", "out of range");
-    return;
-  }
+  buffer->SetRange(offset, size, data);
 
   if (!buffer->IsClientSideArray()) {
     glBufferSubData(target, offset, size, data);
   }
 }
 
 void BufferManager::ValidateAndDoCopyBufferSubData(
     ContextState* context_state, GLenum readtarget, GLenum writetarget,
     GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size) {
   const char* func_name = "glCopyBufferSubData";
+  Buffer* readbuffer = RequestBufferAccess(
+      context_state, readtarget, readoffset, size, func_name);
+  if (!readbuffer)
+    return;
+  Buffer* writebuffer = RequestBufferAccess(
+      context_state, writetarget, writeoffset, size, func_name);
+  if (!writebuffer)
+    return;
+
   ErrorState* error_state = context_state->GetErrorState();
-
-  Buffer* readbuffer = GetBufferInfoForTarget(context_state, readtarget);
-  if (!readbuffer) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
-        "no buffer is bound to readtarget");
-    return;
-  }
-  if (readbuffer->GetMappedRange()) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
-        "buffer bound to readtarget is mapped");
-    return;
-  }
-  if (!readbuffer->CheckRange(readoffset, size)) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, func_name,
-        "readoffset/size out of range");
-    return;
-  }
-
-  Buffer* writebuffer = GetBufferInfoForTarget(context_state, writetarget);
-  if (!writebuffer) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
-        "no buffer is bound to writetarget");
-    return;
-  }
-  if (writebuffer->GetMappedRange()) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
-        "buffer bound to writetarget is mapped");
-    return;
-  }
-  if (!writebuffer->CheckRange(writeoffset, size)) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, func_name,
-        "writeoffset/size out of range");
-    return;
-  }
-
   if (readbuffer == writebuffer &&
       ((writeoffset >= readoffset && writeoffset < readoffset + size) ||
        (readoffset >= writeoffset && readoffset < writeoffset + size))) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, func_name,
         "read/write ranges overlap");
     return;
   }
 
   if (!allow_buffers_on_multiple_targets_) {
     if ((readbuffer->initial_target() == GL_ELEMENT_ARRAY_BUFFER &&
@@ skipping 16 matching lines @@
     GLintptr readoffset,
     Buffer* writebuffer,
     GLenum writetarget,
     GLintptr writeoffset,
     GLsizeiptr size) {
   DCHECK(readbuffer);
   DCHECK(writebuffer);
   if (writebuffer->shadowed()) {
     const void* data = readbuffer->GetRange(readoffset, size);
     DCHECK(data);
-    bool success = writebuffer->SetRange(writeoffset, size, data);
-    DCHECK(success);
+    writebuffer->SetRange(writeoffset, size, data);
   }
 
   glCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size);
 }
 
 void BufferManager::ValidateAndDoGetBufferParameteri64v(
     ContextState* context_state, GLenum target, GLenum pname, GLint64* params) {
   Buffer* buffer = GetBufferInfoForTarget(context_state, target);
   if (!buffer) {
     ERRORSTATE_SET_GL_ERROR(
@@ skipping 163 matching lines @@
                     static_cast<uint64_t>(buffer->size()));
 
     auto guid = gl::GetGLBufferGUIDForTracing(share_group_tracing_guid,
                                               client_buffer_id);
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid);
   }
   return true;
 }
 
+Buffer* BufferManager::RequestBufferAccess(ContextState* context_state,
+                                           GLenum target,
+                                           GLintptr offset,
+                                           GLsizeiptr size,
+                                           const char* func_name) {
+  DCHECK(context_state);
+  ErrorState* error_state = context_state->GetErrorState();
+
+  std::string msg_tag = base::StringPrintf("bound to target 0x%04x", target);
+  Buffer* buffer = GetBufferInfoForTarget(context_state, target);
+  if (!RequestBufferAccess(error_state, buffer, func_name, msg_tag.c_str())) {
+    return nullptr;
+  }
+  if (!buffer->CheckRange(offset, size)) {
+    std::string msg = base::StringPrintf(
+        "%s : offset/size out of range", msg_tag.c_str());
+    ERRORSTATE_SET_GL_ERROR(
+        error_state, GL_INVALID_VALUE, func_name, msg.c_str());
+    return nullptr;
+  }
+  return buffer;
+}
+
+Buffer* BufferManager::RequestBufferAccess(ContextState* context_state,
+                                           GLenum target,
+                                           const char* func_name) {
+  DCHECK(context_state);
+  ErrorState* error_state = context_state->GetErrorState();
+
+  std::string msg_tag = base::StringPrintf("bound to target 0x%04x", target);
+  Buffer* buffer = GetBufferInfoForTarget(context_state, target);
+  return RequestBufferAccess(
+      error_state, buffer, func_name, msg_tag.c_str()) ? buffer : nullptr;
+}
+
+bool BufferManager::RequestBufferAccess(ErrorState* error_state,
+                                        Buffer* buffer,
+                                        const char* func_name,
+                                        const char* message_tag) {
+  DCHECK(error_state);
+
+  if (!buffer || buffer->IsDeleted()) {
+    std::string msg = base::StringPrintf("%s : no buffer", message_tag);
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, func_name,
+                            msg.c_str());
+    return false;
+  }
+  if (buffer->GetMappedRange()) {
+    std::string msg = base::StringPrintf("%s : buffer is mapped", message_tag);
+    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_--;
+}
+
 }  // namespace gles2
 }  // namespace gpu