Revert of Initialize buffers before allowing access to them.

gpu/command_buffer/service/vertex_attrib_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/vertex_attrib_manager.h"
 
 #include <stdint.h>
 
 #include <list>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_manager.h"
@@ skipping 46 matching lines @@
   if (buffer_.get() == buffer) {
     buffer_ = NULL;
   }
 }
 
 bool VertexAttrib::CanAccess(GLuint index) const {
   if (!enabled_) {
     return true;
   }
 
-  DCHECK(buffer_.get() && !buffer_->IsDeleted());
+  if (!buffer_.get() || buffer_->IsDeleted()) {
+    return false;
+  }
+
   // The number of elements that can be accessed.
   GLsizeiptr buffer_size = buffer_->size();
   if (offset_ > buffer_size || real_stride_ == 0) {
     return false;
   }
 
   uint32_t usable_size = buffer_size - offset_;
   GLuint num_elements = usable_size / real_stride_ +
       ((usable_size % real_stride_) >=
        (GLES2Util::GetGroupSizeForBufferType(size_, type_)) ? 1 : 0);
@@ skipping 82 matching lines @@
   }
   for (uint32_t vv = 0; vv < vertex_attribs_.size(); ++vv) {
     vertex_attribs_[vv].Unbind(buffer);
   }
 }
 
 bool VertexAttribManager::ValidateBindings(
     const char* function_name,
     GLES2Decoder* decoder,
     FeatureInfo* feature_info,
-    BufferManager* buffer_manager,
     Program* current_program,
     GLuint max_vertex_accessed,
     bool instanced,
     GLsizei primcount) {
   DCHECK(primcount);
   ErrorState* error_state = decoder->GetErrorState();
   // true if any enabled, used divisor is zero
   bool divisor0 = false;
   bool have_enabled_active_attribs = false;
   const GLuint kInitialBufferId = 0xFFFFFFFFU;
   GLuint current_buffer_id = kInitialBufferId;
   bool use_client_side_arrays_for_stream_buffers = feature_info->workarounds(
       ).use_client_side_arrays_for_stream_buffers;
   // Validate all attribs currently enabled. If they are used by the current
   // program then check that they have enough elements to handle the draw call.
   // If they are not used by the current program check that they have a buffer
   // assigned.
   for (VertexAttribList::iterator it = enabled_vertex_attribs_.begin();
        it != enabled_vertex_attribs_.end(); ++it) {
     VertexAttrib* attrib = *it;
-    Buffer* buffer = attrib->buffer();
-    std::string msg_tag = base::StringPrintf(
-        "attached to enabled attrib %u", attrib->index());
-    if (!buffer_manager->RequestBufferAccess(
-            error_state, buffer, function_name, msg_tag.c_str())) {
-      return false;
-    }
     const Program::VertexAttrib* attrib_info =
         current_program->GetAttribInfoByLocation(attrib->index());
     if (attrib_info) {
       divisor0 |= (attrib->divisor() == 0);
       have_enabled_active_attribs = true;
       GLuint count = attrib->MaxVertexAccessed(primcount, max_vertex_accessed);
       // This attrib is used in the current program.
       if (!attrib->CanAccess(count)) {
         ERRORSTATE_SET_GL_ERROR(
             error_state, GL_INVALID_OPERATION, function_name,
             (std::string(
                 "attempt to access out of range vertices in attribute ") +
              base::UintToString(attrib->index())).c_str());
         return false;
       }
       if (use_client_side_arrays_for_stream_buffers) {
+        Buffer* buffer = attrib->buffer();
         glEnableVertexAttribArray(attrib->index());
         if (buffer->IsClientSideArray()) {
           if (current_buffer_id != 0) {
             current_buffer_id = 0;
             glBindBuffer(GL_ARRAY_BUFFER, 0);
           }
           attrib->set_is_client_side_array(true);
           const void* ptr = buffer->GetRange(attrib->offset(), 0);
           DCHECK(ptr);
           glVertexAttribPointer(
@@ skipping 15 matching lines @@
               attrib->index(),
               attrib->size(),
               attrib->type(),
               attrib->normalized(),
               attrib->gl_stride(),
               ptr);
         }
       }
     } else {
       // This attrib is not used in the current program.
-      if (use_client_side_arrays_for_stream_buffers) {
+      if (!attrib->buffer()) {
+        ERRORSTATE_SET_GL_ERROR(
+            error_state, GL_INVALID_OPERATION, function_name,
+            (std::string(
+                 "attempt to render with no buffer attached to "
+                 "enabled attribute ") +
+                 base::UintToString(attrib->index())).c_str());
+        return false;
+      } else if (use_client_side_arrays_for_stream_buffers) {
+        Buffer* buffer = attrib->buffer();
         // Disable client side arrays for unused attributes else we'll
         // read bad memory
         if (buffer->IsClientSideArray()) {
           // Don't disable attrib 0 since it's special.
           if (attrib->index() > 0) {
             glDisableVertexAttribArray(attrib->index());
           }
         }
       }
     }
@@ skipping 13 matching lines @@
   if (current_buffer_id != kInitialBufferId) {
     // Restore the buffer binding.
     decoder->RestoreBufferBindings();
   }
 
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu