Home | History | Annotate | Download | only in client 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
      6 
      7 #include "base/logging.h"
      8 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
      9 #include "gpu/command_buffer/client/gles2_implementation.h"
     10 
     11 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
     12 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
     13 #endif
     14 
     15 namespace gpu {
     16 namespace gles2 {
     17 
     18 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
     19 
     20 static GLsizei RoundUpToMultipleOf4(GLsizei size) {
     21   return (size + 3) & ~3;
     22 }
     23 
     24 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
     25 
     26 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
     27 static GLuint ToGLuint(const void* ptr) {
     28   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
     29 }
     30 
     31 // This class tracks VertexAttribPointers and helps emulate client side buffers.
     32 //
     33 // The way client side buffers work is we shadow all the Vertex Attribs so we
     34 // know which ones are pointing to client side buffers.
     35 //
     36 // At Draw time, for any attribs pointing to client side buffers we copy them
     37 // to a special VBO and reset the actual vertex attrib pointers to point to this
     38 // VBO.
     39 //
     40 // This also means we have to catch calls to query those values so that when
     41 // an attrib is a client side buffer we pass the info back the user expects.
     42 
     43 class GLES2_IMPL_EXPORT VertexArrayObject {
     44  public:
     45   // Info about Vertex Attributes. This is used to track what the user currently
     46   // has bound on each Vertex Attribute so we can simulate client side buffers
     47   // at glDrawXXX time.
     48   class VertexAttrib {
     49    public:
     50     VertexAttrib()
     51         : enabled_(false),
     52           buffer_id_(0),
     53           size_(4),
     54           type_(GL_FLOAT),
     55           normalized_(GL_FALSE),
     56           pointer_(NULL),
     57           gl_stride_(0),
     58           divisor_(0) {
     59     }
     60 
     61     bool enabled() const {
     62       return enabled_;
     63     }
     64 
     65     void set_enabled(bool enabled) {
     66       enabled_ = enabled;
     67     }
     68 
     69     GLuint buffer_id() const {
     70       return buffer_id_;
     71     }
     72 
     73     void set_buffer_id(GLuint id) {
     74       buffer_id_ = id;
     75     }
     76 
     77     GLenum type() const {
     78       return type_;
     79     }
     80 
     81     GLint size() const {
     82       return size_;
     83     }
     84 
     85     GLsizei stride() const {
     86       return gl_stride_;
     87     }
     88 
     89     GLboolean normalized() const {
     90       return normalized_;
     91     }
     92 
     93     const GLvoid* pointer() const {
     94       return pointer_;
     95     }
     96 
     97     bool IsClientSide() const {
     98       return buffer_id_ == 0;
     99     }
    100 
    101     GLuint divisor() const {
    102       return divisor_;
    103     }
    104 
    105     void SetInfo(
    106         GLuint buffer_id,
    107         GLint size,
    108         GLenum type,
    109         GLboolean normalized,
    110         GLsizei gl_stride,
    111         const GLvoid* pointer) {
    112       buffer_id_ = buffer_id;
    113       size_ = size;
    114       type_ = type;
    115       normalized_ = normalized;
    116       gl_stride_ = gl_stride;
    117       pointer_ = pointer;
    118     }
    119 
    120     void SetDivisor(GLuint divisor) {
    121       divisor_ = divisor;
    122     }
    123 
    124    private:
    125     // Whether or not this attribute is enabled.
    126     bool enabled_;
    127 
    128     // The id of the buffer. 0 = client side buffer.
    129     GLuint buffer_id_;
    130 
    131     // Number of components (1, 2, 3, 4).
    132     GLint size_;
    133 
    134     // GL_BYTE, GL_FLOAT, etc. See glVertexAttribPointer.
    135     GLenum type_;
    136 
    137     // GL_TRUE or GL_FALSE
    138     GLboolean normalized_;
    139 
    140     // The pointer/offset into the buffer.
    141     const GLvoid* pointer_;
    142 
    143     // The stride that will be used to access the buffer. This is the bogus GL
    144     // stride where 0 = compute the stride based on size and type.
    145     GLsizei gl_stride_;
    146 
    147     // Divisor, for geometry instancing.
    148     GLuint divisor_;
    149   };
    150 
    151   typedef std::vector<VertexAttrib> VertexAttribs;
    152 
    153   explicit VertexArrayObject(GLuint max_vertex_attribs);
    154 
    155   void UnbindBuffer(GLuint id);
    156 
    157   bool BindElementArray(GLuint id);
    158 
    159   bool HaveEnabledClientSideBuffers() const;
    160 
    161   void SetAttribEnable(GLuint index, bool enabled);
    162 
    163   void SetAttribPointer(
    164     GLuint buffer_id,
    165     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
    166     const void* ptr);
    167 
    168   bool GetVertexAttrib(
    169       GLuint index, GLenum pname, uint32* param) const;
    170 
    171   void SetAttribDivisor(GLuint index, GLuint divisor);
    172 
    173   bool GetAttribPointer(GLuint index, GLenum pname, void** ptr) const;
    174 
    175   const VertexAttribs& vertex_attribs() const {
    176     return vertex_attribs_;
    177   }
    178 
    179   GLuint bound_element_array_buffer() const {
    180     return bound_element_array_buffer_id_;
    181   }
    182 
    183  private:
    184   const VertexAttrib* GetAttrib(GLuint index) const;
    185 
    186   int num_client_side_pointers_enabled_;
    187 
    188   // The currently bound element array buffer.
    189   GLuint bound_element_array_buffer_id_;
    190 
    191   VertexAttribs vertex_attribs_;
    192 
    193   DISALLOW_COPY_AND_ASSIGN(VertexArrayObject);
    194 };
    195 
    196 VertexArrayObject::VertexArrayObject(GLuint max_vertex_attribs)
    197     : num_client_side_pointers_enabled_(0),
    198       bound_element_array_buffer_id_(0) {
    199   vertex_attribs_.resize(max_vertex_attribs);
    200 }
    201 
    202 void VertexArrayObject::UnbindBuffer(GLuint id) {
    203   if (id == 0) {
    204     return;
    205   }
    206   for (size_t ii = 0; ii < vertex_attribs_.size(); ++ii) {
    207     VertexAttrib& attrib = vertex_attribs_[ii];
    208     if (attrib.buffer_id() == id) {
    209       attrib.set_buffer_id(0);
    210       if (attrib.enabled()) {
    211         ++num_client_side_pointers_enabled_;
    212       }
    213     }
    214   }
    215   if (bound_element_array_buffer_id_ == id) {
    216     bound_element_array_buffer_id_ = 0;
    217   }
    218 }
    219 
    220 bool VertexArrayObject::BindElementArray(GLuint id) {
    221   if (id == bound_element_array_buffer_id_) {
    222     return false;
    223   }
    224   bound_element_array_buffer_id_ = id;
    225   return true;
    226 }
    227 bool VertexArrayObject::HaveEnabledClientSideBuffers() const {
    228   return num_client_side_pointers_enabled_ > 0;
    229 }
    230 
    231 void VertexArrayObject::SetAttribEnable(GLuint index, bool enabled) {
    232   if (index < vertex_attribs_.size()) {
    233     VertexAttrib& attrib = vertex_attribs_[index];
    234     if (attrib.enabled() != enabled) {
    235       if (attrib.IsClientSide()) {
    236         num_client_side_pointers_enabled_ += enabled ? 1 : -1;
    237         DCHECK_GE(num_client_side_pointers_enabled_, 0);
    238       }
    239       attrib.set_enabled(enabled);
    240     }
    241   }
    242 }
    243 
    244 void VertexArrayObject::SetAttribPointer(
    245     GLuint buffer_id,
    246     GLuint index,
    247     GLint size,
    248     GLenum type,
    249     GLboolean normalized,
    250     GLsizei stride,
    251     const void* ptr) {
    252   if (index < vertex_attribs_.size()) {
    253     VertexAttrib& attrib = vertex_attribs_[index];
    254     if (attrib.IsClientSide() && attrib.enabled()) {
    255       --num_client_side_pointers_enabled_;
    256       DCHECK_GE(num_client_side_pointers_enabled_, 0);
    257     }
    258 
    259     attrib.SetInfo(buffer_id, size, type, normalized, stride, ptr);
    260 
    261     if (attrib.IsClientSide() && attrib.enabled()) {
    262       ++num_client_side_pointers_enabled_;
    263     }
    264   }
    265 }
    266 
    267 bool VertexArrayObject::GetVertexAttrib(
    268     GLuint index, GLenum pname, uint32* param) const {
    269   const VertexAttrib* attrib = GetAttrib(index);
    270   if (!attrib) {
    271     return false;
    272   }
    273 
    274   switch (pname) {
    275     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
    276       *param = attrib->buffer_id();
    277       break;
    278     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
    279       *param = attrib->enabled();
    280       break;
    281     case GL_VERTEX_ATTRIB_ARRAY_SIZE:
    282       *param = attrib->size();
    283       break;
    284     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
    285       *param = attrib->stride();
    286       break;
    287     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
    288       *param = attrib->type();
    289       break;
    290     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
    291       *param = attrib->normalized();
    292       break;
    293     default:
    294       return false;  // pass through to service side.
    295       break;
    296   }
    297   return true;
    298 }
    299 
    300 void VertexArrayObject::SetAttribDivisor(GLuint index, GLuint divisor) {
    301   if (index < vertex_attribs_.size()) {
    302     VertexAttrib& attrib = vertex_attribs_[index];
    303     attrib.SetDivisor(divisor);
    304   }
    305 }
    306 
    307 // Gets the Attrib pointer for an attrib but only if it's a client side
    308 // pointer. Returns true if it got the pointer.
    309 bool VertexArrayObject::GetAttribPointer(
    310     GLuint index, GLenum pname, void** ptr) const {
    311   const VertexAttrib* attrib = GetAttrib(index);
    312   if (attrib && pname == GL_VERTEX_ATTRIB_ARRAY_POINTER) {
    313     *ptr = const_cast<void*>(attrib->pointer());
    314     return true;
    315   }
    316   return false;
    317 }
    318 
    319 // Gets an attrib if it's in range and it's client side.
    320 const VertexArrayObject::VertexAttrib* VertexArrayObject::GetAttrib(
    321     GLuint index) const {
    322   if (index < vertex_attribs_.size()) {
    323     const VertexAttrib* attrib = &vertex_attribs_[index];
    324     return attrib;
    325   }
    326   return NULL;
    327 }
    328 
    329 VertexArrayObjectManager::VertexArrayObjectManager(
    330     GLuint max_vertex_attribs,
    331     GLuint array_buffer_id,
    332     GLuint element_array_buffer_id)
    333     : max_vertex_attribs_(max_vertex_attribs),
    334       array_buffer_id_(array_buffer_id),
    335       array_buffer_size_(0),
    336       array_buffer_offset_(0),
    337       element_array_buffer_id_(element_array_buffer_id),
    338       element_array_buffer_size_(0),
    339       collection_buffer_size_(0),
    340       default_vertex_array_object_(new VertexArrayObject(max_vertex_attribs)),
    341       bound_vertex_array_object_(default_vertex_array_object_) {
    342 }
    343 
    344 VertexArrayObjectManager::~VertexArrayObjectManager() {
    345   for (VertexArrayObjectMap::iterator it = vertex_array_objects_.begin();
    346        it != vertex_array_objects_.end(); ++it) {
    347     delete it->second;
    348   }
    349   delete default_vertex_array_object_;
    350 }
    351 
    352 bool VertexArrayObjectManager::IsReservedId(GLuint id) const {
    353   return (id != 0 &&
    354           (id == array_buffer_id_ || id == element_array_buffer_id_));
    355 }
    356 
    357 GLuint VertexArrayObjectManager::bound_element_array_buffer() const {
    358   return bound_vertex_array_object_->bound_element_array_buffer();
    359 }
    360 
    361 void VertexArrayObjectManager::UnbindBuffer(GLuint id) {
    362   bound_vertex_array_object_->UnbindBuffer(id);
    363 }
    364 
    365 bool VertexArrayObjectManager::BindElementArray(GLuint id) {
    366   return  bound_vertex_array_object_->BindElementArray(id);
    367 }
    368 
    369 void VertexArrayObjectManager::GenVertexArrays(
    370     GLsizei n, const GLuint* arrays) {
    371   DCHECK_GE(n, 0);
    372   for (GLsizei i = 0; i < n; ++i) {
    373     std::pair<VertexArrayObjectMap::iterator, bool> result =
    374         vertex_array_objects_.insert(std::make_pair(
    375             arrays[i], new VertexArrayObject(max_vertex_attribs_)));
    376     DCHECK(result.second);
    377   }
    378 }
    379 
    380 void VertexArrayObjectManager::DeleteVertexArrays(
    381     GLsizei n, const GLuint* arrays) {
    382   DCHECK_GE(n, 0);
    383   for (GLsizei i = 0; i < n; ++i) {
    384     GLuint id = arrays[i];
    385     if (id) {
    386       VertexArrayObjectMap::iterator it = vertex_array_objects_.find(id);
    387       if (it != vertex_array_objects_.end()) {
    388         if (bound_vertex_array_object_ == it->second) {
    389           bound_vertex_array_object_ = default_vertex_array_object_;
    390         }
    391         delete it->second;
    392         vertex_array_objects_.erase(it);
    393       }
    394     }
    395   }
    396 }
    397 
    398 bool VertexArrayObjectManager::BindVertexArray(GLuint array, bool* changed) {
    399   *changed = false;
    400   VertexArrayObject* vertex_array_object = default_vertex_array_object_;
    401   if (array != 0) {
    402     VertexArrayObjectMap::iterator it = vertex_array_objects_.find(array);
    403     if (it == vertex_array_objects_.end()) {
    404       return false;
    405     }
    406     vertex_array_object = it->second;
    407   }
    408   *changed = vertex_array_object != bound_vertex_array_object_;
    409   bound_vertex_array_object_ = vertex_array_object;
    410   return true;
    411 }
    412 
    413 bool VertexArrayObjectManager::HaveEnabledClientSideBuffers() const {
    414   return bound_vertex_array_object_->HaveEnabledClientSideBuffers();
    415 }
    416 
    417 void VertexArrayObjectManager::SetAttribEnable(GLuint index, bool enabled) {
    418   bound_vertex_array_object_->SetAttribEnable(index, enabled);
    419 }
    420 
    421 bool VertexArrayObjectManager::GetVertexAttrib(
    422     GLuint index, GLenum pname, uint32* param) {
    423   return bound_vertex_array_object_->GetVertexAttrib(index, pname, param);
    424 }
    425 
    426 bool VertexArrayObjectManager::GetAttribPointer(
    427     GLuint index, GLenum pname, void** ptr) const {
    428   return bound_vertex_array_object_->GetAttribPointer(index, pname, ptr);
    429 }
    430 
    431 bool VertexArrayObjectManager::SetAttribPointer(
    432     GLuint buffer_id,
    433     GLuint index,
    434     GLint size,
    435     GLenum type,
    436     GLboolean normalized,
    437     GLsizei stride,
    438     const void* ptr) {
    439   // Client side arrays are not allowed in vaos.
    440   if (buffer_id == 0 && !IsDefaultVAOBound()) {
    441     return false;
    442   }
    443   bound_vertex_array_object_->SetAttribPointer(
    444       buffer_id, index, size, type, normalized, stride, ptr);
    445   return true;
    446 }
    447 
    448 void VertexArrayObjectManager::SetAttribDivisor(GLuint index, GLuint divisor) {
    449   bound_vertex_array_object_->SetAttribDivisor(index, divisor);
    450 }
    451 
    452 // Collects the data into the collection buffer and returns the number of
    453 // bytes collected.
    454 GLsizei VertexArrayObjectManager::CollectData(
    455     const void* data,
    456     GLsizei bytes_per_element,
    457     GLsizei real_stride,
    458     GLsizei num_elements) {
    459   GLsizei bytes_needed = bytes_per_element * num_elements;
    460   if (collection_buffer_size_ < bytes_needed) {
    461     collection_buffer_.reset(new int8[bytes_needed]);
    462     collection_buffer_size_ = bytes_needed;
    463   }
    464   const int8* src = static_cast<const int8*>(data);
    465   int8* dst = collection_buffer_.get();
    466   int8* end = dst + bytes_per_element * num_elements;
    467   for (; dst < end; src += real_stride, dst += bytes_per_element) {
    468     memcpy(dst, src, bytes_per_element);
    469   }
    470   return bytes_needed;
    471 }
    472 
    473 bool VertexArrayObjectManager::IsDefaultVAOBound() const {
    474   return bound_vertex_array_object_ == default_vertex_array_object_;
    475 }
    476 
    477 // Returns true if buffers were setup.
    478 bool VertexArrayObjectManager::SetupSimulatedClientSideBuffers(
    479     const char* function_name,
    480     GLES2Implementation* gl,
    481     GLES2CmdHelper* gl_helper,
    482     GLsizei num_elements,
    483     GLsizei primcount,
    484     bool* simulated) {
    485   *simulated = false;
    486 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
    487   if (!bound_vertex_array_object_->HaveEnabledClientSideBuffers()) {
    488     return true;
    489   }
    490   if (!IsDefaultVAOBound()) {
    491     gl->SetGLError(
    492         GL_INVALID_OPERATION, function_name,
    493         "client side arrays not allowed with vertex array object");
    494     return false;
    495   }
    496   *simulated = true;
    497   GLsizei total_size = 0;
    498   // Compute the size of the buffer we need.
    499   const VertexArrayObject::VertexAttribs& vertex_attribs =
    500       bound_vertex_array_object_->vertex_attribs();
    501   for (GLuint ii = 0; ii < vertex_attribs.size(); ++ii) {
    502     const VertexArrayObject::VertexAttrib& attrib = vertex_attribs[ii];
    503     if (attrib.IsClientSide() && attrib.enabled()) {
    504       size_t bytes_per_element =
    505           GLES2Util::GetGLTypeSizeForTexturesAndBuffers(attrib.type()) *
    506           attrib.size();
    507       GLsizei elements = (primcount && attrib.divisor() > 0) ?
    508           ((primcount - 1) / attrib.divisor() + 1) : num_elements;
    509       total_size += RoundUpToMultipleOf4(bytes_per_element * elements);
    510     }
    511   }
    512   gl_helper->BindBuffer(GL_ARRAY_BUFFER, array_buffer_id_);
    513   array_buffer_offset_ = 0;
    514   if (total_size > array_buffer_size_) {
    515     gl->BufferDataHelper(GL_ARRAY_BUFFER, total_size, NULL, GL_DYNAMIC_DRAW);
    516     array_buffer_size_ = total_size;
    517   }
    518   for (GLuint ii = 0; ii < vertex_attribs.size(); ++ii) {
    519     const VertexArrayObject::VertexAttrib& attrib = vertex_attribs[ii];
    520     if (attrib.IsClientSide() && attrib.enabled()) {
    521       size_t bytes_per_element =
    522           GLES2Util::GetGLTypeSizeForTexturesAndBuffers(attrib.type()) *
    523           attrib.size();
    524       GLsizei real_stride = attrib.stride() ?
    525           attrib.stride() : static_cast<GLsizei>(bytes_per_element);
    526       GLsizei elements = (primcount && attrib.divisor() > 0) ?
    527           ((primcount - 1) / attrib.divisor() + 1) : num_elements;
    528       GLsizei bytes_collected = CollectData(
    529           attrib.pointer(), bytes_per_element, real_stride, elements);
    530       gl->BufferSubDataHelper(
    531           GL_ARRAY_BUFFER, array_buffer_offset_, bytes_collected,
    532           collection_buffer_.get());
    533       gl_helper->VertexAttribPointer(
    534           ii, attrib.size(), attrib.type(), attrib.normalized(), 0,
    535           array_buffer_offset_);
    536       array_buffer_offset_ += RoundUpToMultipleOf4(bytes_collected);
    537       DCHECK_LE(array_buffer_offset_, array_buffer_size_);
    538     }
    539   }
    540 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
    541   return true;
    542 }
    543 
    544 // Copies in indices to the service and returns the highest index accessed + 1
    545 bool VertexArrayObjectManager::SetupSimulatedIndexAndClientSideBuffers(
    546     const char* function_name,
    547     GLES2Implementation* gl,
    548     GLES2CmdHelper* gl_helper,
    549     GLsizei count,
    550     GLenum type,
    551     GLsizei primcount,
    552     const void* indices,
    553     GLuint* offset,
    554     bool* simulated) {
    555   *simulated = false;
    556   *offset = ToGLuint(indices);
    557 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
    558   GLsizei num_elements = 0;
    559   if (bound_vertex_array_object_->bound_element_array_buffer() == 0) {
    560     *simulated = true;
    561     *offset = 0;
    562     GLsizei max_index = -1;
    563     switch (type) {
    564       case GL_UNSIGNED_BYTE: {
    565         const uint8* src = static_cast<const uint8*>(indices);
    566         for (GLsizei ii = 0; ii < count; ++ii) {
    567           if (src[ii] > max_index) {
    568             max_index = src[ii];
    569           }
    570         }
    571         break;
    572       }
    573       case GL_UNSIGNED_SHORT: {
    574         const uint16* src = static_cast<const uint16*>(indices);
    575         for (GLsizei ii = 0; ii < count; ++ii) {
    576           if (src[ii] > max_index) {
    577             max_index = src[ii];
    578           }
    579         }
    580         break;
    581       }
    582       case GL_UNSIGNED_INT: {
    583         uint32 max_glsizei = static_cast<uint32>(
    584             std::numeric_limits<GLsizei>::max());
    585         const uint32* src = static_cast<const uint32*>(indices);
    586         for (GLsizei ii = 0; ii < count; ++ii) {
    587           // Other parts of the API use GLsizei (signed) to store limits.
    588           // As such, if we encounter a index that cannot be represented with
    589           // an unsigned int we need to flag it as an error here.
    590           if(src[ii] > max_glsizei) {
    591             gl->SetGLError(
    592                 GL_INVALID_OPERATION, function_name, "index too large.");
    593             return false;
    594           }
    595           GLsizei signed_index = static_cast<GLsizei>(src[ii]);
    596           if (signed_index > max_index) {
    597             max_index = signed_index;
    598           }
    599         }
    600         break;
    601       }
    602       default:
    603         break;
    604     }
    605     gl_helper->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, element_array_buffer_id_);
    606     GLsizei bytes_per_element =
    607         GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type);
    608     GLsizei bytes_needed = bytes_per_element * count;
    609     if (bytes_needed > element_array_buffer_size_) {
    610       element_array_buffer_size_ = bytes_needed;
    611       gl->BufferDataHelper(
    612           GL_ELEMENT_ARRAY_BUFFER, bytes_needed, NULL, GL_DYNAMIC_DRAW);
    613     }
    614     gl->BufferSubDataHelper(
    615         GL_ELEMENT_ARRAY_BUFFER, 0, bytes_needed, indices);
    616 
    617     num_elements = max_index + 1;
    618   } else if (bound_vertex_array_object_->HaveEnabledClientSideBuffers()) {
    619     // Index buffer is GL buffer. Ask the service for the highest vertex
    620     // that will be accessed. Note: It doesn't matter if another context
    621     // changes the contents of any of the buffers. The service will still
    622     // validate the indices. We just need to know how much to copy across.
    623     num_elements = gl->GetMaxValueInBufferCHROMIUMHelper(
    624         bound_vertex_array_object_->bound_element_array_buffer(),
    625         count, type, ToGLuint(indices)) + 1;
    626   }
    627 
    628   bool simulated_client_side_buffers = false;
    629   SetupSimulatedClientSideBuffers(
    630       function_name, gl, gl_helper, num_elements, primcount,
    631       &simulated_client_side_buffers);
    632   *simulated = *simulated || simulated_client_side_buffers;
    633 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
    634   return true;
    635 }
    636 
    637 }  // namespace gles2
    638 }  // namespace gpu
    639 
    640 
    641