Fix bug in SimulateAttrib0 that did not check for out of memory.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 1046 matching lines @@
   // command.
   void CopyRealGLErrorsToWrapper();
 
   // Clear all real GL errors. This is to prevent the client from seeing any
   // errors caused by GL calls that it was not responsible for issuing.
   void ClearRealGLErrors();
 
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(GLuint max_vertex_accessed);
 
-  // Returns true if attrib0 was simulated.
-  bool SimulateAttrib0(GLuint max_vertex_accessed);
+  // Returns true if successful, simulated will be true if attrib0 was
+  // simulated.
+  bool SimulateAttrib0(GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForSimulatedAttrib0();
 
   // Returns true if textures were set.
   bool SetBlackTextureForNonRenderableTextures();
   void RestoreStateForNonRenderableTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForSimulatedFixedAttribs();
 
@@ skipping 3159 matching lines @@
             GL_INVALID_OPERATION,
             "glDrawXXX: attempt to render with no buffer attached to enabled "
             "attrib");
         return false;
       }
     }
   }
   return true;
 }
 
-bool GLES2DecoderImpl::SimulateAttrib0(GLuint max_vertex_accessed) {
+bool GLES2DecoderImpl::SimulateAttrib0(
+    GLuint max_vertex_accessed, bool* simulated) {
+  DCHECK(simulated);
+  *simulated = false;
+
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
-    return false;
+    return true;
 
   const VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_.GetVertexAttribInfo(0);
   // If it's enabled or it's not used then we don't need to do anything.
   bool attrib_0_used = current_program_->GetAttribInfoByLocation(0) != NULL;
   if (info->enabled() && attrib_0_used) {
-    return false;
+    return true;
   }
 
-  typedef VertexAttribManager::VertexAttribInfo::Vec4 Vec4;
-
-  glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
-
   // Make a buffer with a single repeated vec4 value enough to
   // simulate the constant value that is supposed to be here.
   // This is required to emulate GLES2 on GL.
+  typedef VertexAttribManager::VertexAttribInfo::Vec4 Vec4;
+
   GLsizei num_vertices = max_vertex_accessed + 1;
-  GLsizei size_needed = num_vertices * sizeof(Vec4);  // NOLINT
+  GLsizei size_needed = 0;
+
+  if (num_vertices < 0 || !SafeMultiply(
+      num_vertices, static_cast<GLsizei>(sizeof(Vec4)), &size_needed)) {
+    SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+    return false;
+  }
+
+  CopyRealGLErrorsToWrapper();
+  glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
+
   if (size_needed > attrib_0_size_) {
     glBufferData(GL_ARRAY_BUFFER, size_needed, NULL, GL_DYNAMIC_DRAW);
-    // TODO(gman): check for error here?
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR) {
+      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+      return false;
+    }
     attrib_0_buffer_matches_value_ = false;
   }
   if (attrib_0_used &&
       (!attrib_0_buffer_matches_value_ ||
        (info->value().v[0] != attrib_0_value_.v[0] ||
         info->value().v[1] != attrib_0_value_.v[1] ||
         info->value().v[2] != attrib_0_value_.v[2] ||
         info->value().v[3] != attrib_0_value_.v[3]))) {
     std::vector<Vec4> temp(num_vertices, info->value());
     glBufferSubData(GL_ARRAY_BUFFER, 0, size_needed, &temp[0].v[0]);
     attrib_0_buffer_matches_value_ = true;
     attrib_0_value_ = info->value();
     attrib_0_size_ = size_needed;
   }
 
   glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
 
+  *simulated = true;
   return true;
 }
 
 void GLES2DecoderImpl::RestoreStateForSimulatedAttrib0() {
   const VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_.GetVertexAttribInfo(0);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
   BufferManager::BufferInfo* buffer_info = info->buffer();
   glBindBuffer(GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
   glVertexAttribPointer(
@@ skipping 14 matching lines @@
     return true;
   }
 
   // NOTE: we could be smart and try to check if a buffer is used
   // twice in 2 different attribs, find the overlapping parts and therefore
   // duplicate the minimum amount of data but this whole code path is not meant
   // to be used normally. It's just here to pass that OpenGL ES 2.0 conformance
   // tests so we just add to the buffer attrib used.
 
   // Compute the number of elements needed.
-  int num_vertices = max_vertex_accessed + 1;
+  GLsizei num_vertices = max_vertex_accessed + 1;
+  if (num_vertices < 0) {
+    SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+    return false;
+  }
+
   int elements_needed = 0;
   const VertexAttribManager::VertexAttribInfoList& infos =
       vertex_attrib_manager_.GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         current_program_->GetAttribInfoByLocation(info->index());
     if (attrib_info &&
         info->CanAccess(max_vertex_accessed) &&
         info->type() == GL_FIXED) {
       int elements_used = 0;
       if (!SafeMultiply(
           static_cast<int>(num_vertices),
           info->size(), &elements_used) ||
           !SafeAdd(elements_needed, elements_used, &elements_needed)) {
         SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
         return false;
       }
     }
   }
 
   const int kSizeOfFloat = sizeof(float);  // NOLINT
   int size_needed = 0;
   if (!SafeMultiply(elements_needed, kSizeOfFloat, &size_needed)) {
     SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
     return false;
   }
 
+  CopyRealGLErrorsToWrapper();
 
   glBindBuffer(GL_ARRAY_BUFFER, fixed_attrib_buffer_id_);
   if (size_needed > fixed_attrib_buffer_size_) {
     glBufferData(GL_ARRAY_BUFFER, size_needed, NULL, GL_DYNAMIC_DRAW);
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR) {
+      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
+      return false;
+    }
   }
 
   // Copy the elements and convert to float
   GLintptr offset = 0;
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
            infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         current_program_->GetAttribInfoByLocation(info->index());
     if (attrib_info &&
@@ skipping 49 matching lines @@
     SetGLError(GL_INVALID_VALUE, "glDrawArrays: first < 0");
     return error::kNoError;
   }
 
   if (count == 0) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed = first + count - 1;
   if (IsDrawValid(max_vertex_accessed)) {
-    bool simulated_attrib_0 = SimulateAttrib0(max_vertex_accessed);
+    bool simulated_attrib_0 = false;
+    if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
+      return error::kNoError;
+    }
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       glDrawArrays(mode, first, count);
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
@@ skipping 50 matching lines @@
 
   GLuint max_vertex_accessed;
   if (!bound_element_array_buffer_->GetMaxValueForRange(
       offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(max_vertex_accessed)) {
-    bool simulated_attrib_0 = SimulateAttrib0(max_vertex_accessed);
+    bool simulated_attrib_0 = false;
+    if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
+      return error::kNoError;
+    }
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       glDrawElements(mode, count, type, indices);
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
@@ skipping 2320 matching lines @@
   return false;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu