PepperGL: Enable client side arrays support.

gpu/command_buffer/client/vertex_array_object_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/client/vertex_array_object_manager.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
-#if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
-#define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
-#endif
-
 namespace gpu {
 namespace gles2 {
 
-#if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
-
 static GLsizei RoundUpToMultipleOf4(GLsizei size) {
   return (size + 3) & ~3;
 }
 
-#endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
-
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 static GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
 // This class tracks VertexAttribPointers and helps emulate client side buffers.
 //
 // The way client side buffers work is we shadow all the Vertex Attribs so we
 // know which ones are pointing to client side buffers.
 //
@@ skipping 286 matching lines @@
   if (index < vertex_attribs_.size()) {
     const VertexAttrib* attrib = &vertex_attribs_[index];
     return attrib;
   }
   return NULL;
 }
 
 VertexArrayObjectManager::VertexArrayObjectManager(
     GLuint max_vertex_attribs,
     GLuint array_buffer_id,
-    GLuint element_array_buffer_id)
+    GLuint element_array_buffer_id,
+    bool support_client_side_arrays)
     : max_vertex_attribs_(max_vertex_attribs),
       array_buffer_id_(array_buffer_id),
       array_buffer_size_(0),
       array_buffer_offset_(0),
       element_array_buffer_id_(element_array_buffer_id),
       element_array_buffer_size_(0),
       collection_buffer_size_(0),
       default_vertex_array_object_(new VertexArrayObject(max_vertex_attribs)),
-      bound_vertex_array_object_(default_vertex_array_object_) {
+      bound_vertex_array_object_(default_vertex_array_object_),
+      support_client_side_arrays_(support_client_side_arrays) {
 }
 
 VertexArrayObjectManager::~VertexArrayObjectManager() {
   for (VertexArrayObjectMap::iterator it = vertex_array_objects_.begin();
        it != vertex_array_objects_.end(); ++it) {
     delete it->second;
   }
   delete default_vertex_array_object_;
 }
 
@@ skipping 124 matching lines @@
 
 // Returns true if buffers were setup.
 bool VertexArrayObjectManager::SetupSimulatedClientSideBuffers(
     const char* function_name,
     GLES2Implementation* gl,
     GLES2CmdHelper* gl_helper,
     GLsizei num_elements,
     GLsizei primcount,
     bool* simulated) {
   *simulated = false;
-#if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
+  if (!support_client_side_arrays_)
+    return true;
   if (!bound_vertex_array_object_->HaveEnabledClientSideBuffers()) {
     return true;
   }
   if (!IsDefaultVAOBound()) {
     gl->SetGLError(
         GL_INVALID_OPERATION, function_name,
         "client side arrays not allowed with vertex array object");
     return false;
   }
   *simulated = true;
@@ skipping 33 matching lines @@
       gl->BufferSubDataHelper(
           GL_ARRAY_BUFFER, array_buffer_offset_, bytes_collected,
           collection_buffer_.get());
       gl_helper->VertexAttribPointer(
           ii, attrib.size(), attrib.type(), attrib.normalized(), 0,
           array_buffer_offset_);
       array_buffer_offset_ += RoundUpToMultipleOf4(bytes_collected);
       DCHECK_LE(array_buffer_offset_, array_buffer_size_);
     }
   }
-#endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   return true;
 }
 
 // Copies in indices to the service and returns the highest index accessed + 1
 bool VertexArrayObjectManager::SetupSimulatedIndexAndClientSideBuffers(
     const char* function_name,
     GLES2Implementation* gl,
     GLES2CmdHelper* gl_helper,
     GLsizei count,
     GLenum type,
     GLsizei primcount,
     const void* indices,
     GLuint* offset,
     bool* simulated) {
   *simulated = false;
   *offset = ToGLuint(indices);
-#if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
+  if (!support_client_side_arrays_)
+    return true;
   GLsizei num_elements = 0;
   if (bound_vertex_array_object_->bound_element_array_buffer() == 0) {
     *simulated = true;
     *offset = 0;
     GLsizei max_index = -1;
     switch (type) {
       case GL_UNSIGNED_BYTE: {
         const uint8* src = static_cast<const uint8*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           if (src[ii] > max_index) {
@@ skipping 55 matching lines @@
     num_elements = gl->GetMaxValueInBufferCHROMIUMHelper(
         bound_vertex_array_object_->bound_element_array_buffer(),
         count, type, ToGLuint(indices)) + 1;
   }
 
   bool simulated_client_side_buffers = false;
   SetupSimulatedClientSideBuffers(
       function_name, gl, gl_helper, num_elements, primcount,
       &simulated_client_side_buffers);
   *simulated = *simulated || simulated_client_side_buffers;
-#endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu