Auto-generate null checks for pointer arguemnts in the passthrough cmd decoder.

gpu/command_buffer/service/gles2_cmd_decoder_passthrough_handlers_autogen.cc

 // Copyright 2014 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 297 matching lines @@
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoClearBufferfv(buffer, drawbuffers, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleClearBufferivImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::ClearBufferivImmediate& c =
       *static_cast<const volatile gles2::cmds::ClearBufferivImmediate*>(
           cmd_data);
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* value = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoClearBufferiv(buffer, drawbuffers, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleClearBufferuivImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::ClearBufferuivImmediate& c =
       *static_cast<const volatile gles2::cmds::ClearBufferuivImmediate*>(
           cmd_data);
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* value = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoClearBufferuiv(buffer, drawbuffers, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleClearColor(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 166 matching lines @@
   const volatile gles2::cmds::DeleteBuffersImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteBuffersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* buffers = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (buffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteBuffers(n, buffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteFramebuffersImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::DeleteFramebuffersImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteFramebuffersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* framebuffers =
       GetImmediateDataAs<volatile const GLuint*>(c, data_size,
                                                  immediate_data_size);
+  if (framebuffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteFramebuffers(n, framebuffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteProgram(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 14 matching lines @@
       *static_cast<const volatile gles2::cmds::DeleteRenderbuffersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* renderbuffers =
       GetImmediateDataAs<volatile const GLuint*>(c, data_size,
                                                  immediate_data_size);
+  if (renderbuffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteRenderbuffers(n, renderbuffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteSamplersImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::DeleteSamplersImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteSamplersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* samplers = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (samplers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteSamplers(n, samplers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteSync(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 26 matching lines @@
   const volatile gles2::cmds::DeleteTexturesImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteTexturesImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* textures = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (textures == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteTextures(n, textures);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::HandleDeleteTransformFeedbacksImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::DeleteTransformFeedbacksImmediate& c =
       *static_cast<
           const volatile gles2::cmds::DeleteTransformFeedbacksImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* ids = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (ids == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteTransformFeedbacks(n, ids);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDepthFunc(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 195 matching lines @@
     const volatile void* cmd_data) {
   const volatile gles2::cmds::GenBuffersImmediate& c =
       *static_cast<const volatile gles2::cmds::GenBuffersImmediate*>(cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* buffers =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (buffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenBuffers(n, buffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGenerateMipmap(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 13 matching lines @@
   const volatile gles2::cmds::GenFramebuffersImmediate& c =
       *static_cast<const volatile gles2::cmds::GenFramebuffersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* framebuffers =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (framebuffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenFramebuffers(n, framebuffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGenRenderbuffersImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::GenRenderbuffersImmediate& c =
       *static_cast<const volatile gles2::cmds::GenRenderbuffersImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* renderbuffers =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (renderbuffers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenRenderbuffers(n, renderbuffers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGenSamplersImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::GenSamplersImmediate& c =
       *static_cast<const volatile gles2::cmds::GenSamplersImmediate*>(cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* samplers =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (samplers == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenSamplers(n, samplers);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGenTexturesImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::GenTexturesImmediate& c =
       *static_cast<const volatile gles2::cmds::GenTexturesImmediate*>(cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* textures =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (textures == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenTextures(n, textures);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGenTransformFeedbacksImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::GenTransformFeedbacksImmediate& c =
       *static_cast<const volatile gles2::cmds::GenTransformFeedbacksImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* ids =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (ids == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenTransformFeedbacks(n, ids);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleGetBooleanv(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 663 matching lines @@
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLenum* attachments =
       GetImmediateDataAs<volatile const GLenum*>(c, data_size,
                                                  immediate_data_size);
+  if (attachments == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoInvalidateFramebuffer(target, count, attachments);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::HandleInvalidateSubFramebufferImmediate(
     uint32_t immediate_data_size,
@@ skipping 12 matching lines @@
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLenum* attachments =
       GetImmediateDataAs<volatile const GLenum*>(c, data_size,
                                                  immediate_data_size);
   GLint x = static_cast<GLint>(c.x);
   GLint y = static_cast<GLint>(c.y);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
+  if (attachments == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoInvalidateSubFramebuffer(target, count, attachments, x,
                                                   y, width, height);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleIsBuffer(
     uint32_t immediate_data_size,
@@ skipping 324 matching lines @@
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* params = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (params == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoSamplerParameterfv(sampler, pname, params);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleSamplerParameteri(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* params = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (params == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoSamplerParameteriv(sampler, pname, params);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleScissor(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 153 matching lines @@
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* params = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (params == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoTexParameterfv(target, pname, params);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleTexParameteri(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* params = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (params == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoTexParameteriv(target, pname, params);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleTexStorage3D(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 68 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* v = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform1fv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform1i(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 18 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* v = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform1iv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform1ui(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 18 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLuint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* v = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform1uiv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform2f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* v = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform2fv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform2i(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* v = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform2iv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform2ui(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLuint), 2, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* v = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform2uiv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform3f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* v = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform3fv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform3i(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* v = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform3iv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform3ui(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLuint), 3, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* v = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform3uiv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform4f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 21 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* v = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform4fv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform4i(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 21 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* v = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform4iv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniform4ui(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 21 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLuint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* v = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (v == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniform4uiv(location, count, v);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix2fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix2fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix2fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix2fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix2x3fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix2x3fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix2x3fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 6, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix2x3fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix2x4fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix2x4fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix2x4fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 8, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix2x4fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix3fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix3fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix3fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix3fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix3x2fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix3x2fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix3x2fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 6, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix3x2fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix3x4fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix3x4fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix3x4fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 12, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix3x4fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix4fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix4fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix4fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix4fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix4x2fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix4x2fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix4x2fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 8, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix4x2fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUniformMatrix4x3fvImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::UniformMatrix4x3fvImmediate& c =
       *static_cast<const volatile gles2::cmds::UniformMatrix4x3fvImmediate*>(
           cmd_data);
   GLint location = static_cast<GLint>(c.location);
   GLsizei count = static_cast<GLsizei>(c.count);
   GLboolean transpose = static_cast<GLboolean>(c.transpose);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLfloat), 12, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* value = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (value == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix4x3fv(location, count, transpose, value);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleUseProgram(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 43 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* values = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttrib1fv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleVertexAttrib2f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 18 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* values = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttrib2fv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleVertexAttrib3f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* values = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttrib3fv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleVertexAttrib4f(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* values = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttrib4fv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleVertexAttribI4i(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* values = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttribI4iv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleVertexAttribI4ui(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 20 matching lines @@
   GLuint indx = static_cast<GLuint>(c.indx);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* values = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (values == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoVertexAttribI4uiv(indx, values);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleViewport(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 122 matching lines @@
   const volatile gles2::cmds::GenQueriesEXTImmediate& c =
       *static_cast<const volatile gles2::cmds::GenQueriesEXTImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* queries =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (queries == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenQueriesEXT(n, queries);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteQueriesEXTImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::DeleteQueriesEXTImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteQueriesEXTImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* queries = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (queries == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteQueriesEXT(n, queries);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleBeginTransformFeedback(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 34 matching lines @@
   const volatile gles2::cmds::GenVertexArraysOESImmediate& c =
       *static_cast<const volatile gles2::cmds::GenVertexArraysOESImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile GLuint* arrays =
       GetImmediateDataAs<volatile GLuint*>(c, data_size, immediate_data_size);
+  if (arrays == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoGenVertexArraysOES(n, arrays);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleDeleteVertexArraysOESImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::DeleteVertexArraysOESImmediate& c =
       *static_cast<const volatile gles2::cmds::DeleteVertexArraysOESImmediate*>(
           cmd_data);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* arrays = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (arrays == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDeleteVertexArraysOES(n, arrays);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleIsVertexArrayOES(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 158 matching lines @@
   GLenum target = static_cast<GLenum>(c.target);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLbyte), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLbyte* mailbox = GetImmediateDataAs<volatile const GLbyte*>(
       c, data_size, immediate_data_size);
+  if (mailbox == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoProduceTextureCHROMIUM(target, mailbox);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::HandleProduceTextureDirectCHROMIUMImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::ProduceTextureDirectCHROMIUMImmediate& c =
       *static_cast<
           const volatile gles2::cmds::ProduceTextureDirectCHROMIUMImmediate*>(
           cmd_data);
   GLuint texture = c.texture;
   GLenum target = static_cast<GLenum>(c.target);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLbyte), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLbyte* mailbox = GetImmediateDataAs<volatile const GLbyte*>(
       c, data_size, immediate_data_size);
+  if (mailbox == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoProduceTextureDirectCHROMIUM(texture, target, mailbox);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleConsumeTextureCHROMIUMImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::ConsumeTextureCHROMIUMImmediate& c = *static_cast<
       const volatile gles2::cmds::ConsumeTextureCHROMIUMImmediate*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLbyte), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLbyte* mailbox = GetImmediateDataAs<volatile const GLbyte*>(
       c, data_size, immediate_data_size);
+  if (mailbox == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoConsumeTextureCHROMIUM(target, mailbox);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::HandleCreateAndConsumeTextureINTERNALImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::CreateAndConsumeTextureINTERNALImmediate& c =
       *static_cast<const volatile gles2::cmds::
                        CreateAndConsumeTextureINTERNALImmediate*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLuint texture = static_cast<GLuint>(c.texture);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLbyte), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLbyte* mailbox = GetImmediateDataAs<volatile const GLbyte*>(
       c, data_size, immediate_data_size);
+  if (mailbox == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error =
       DoCreateAndConsumeTextureINTERNAL(target, texture, mailbox);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleBindTexImage2DCHROMIUM(
     uint32_t immediate_data_size,
@@ skipping 47 matching lines @@
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLenum* attachments =
       GetImmediateDataAs<volatile const GLenum*>(c, data_size,
                                                  immediate_data_size);
+  if (attachments == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDiscardFramebufferEXT(target, count, attachments);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleLoseContextCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 18 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLenum* bufs = GetImmediateDataAs<volatile const GLenum*>(
       c, data_size, immediate_data_size);
+  if (bufs == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoDrawBuffersEXT(count, bufs);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::HandleScheduleCALayerInUseQueryCHROMIUMImmediate(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   const volatile gles2::cmds::ScheduleCALayerInUseQueryCHROMIUMImmediate& c =
       *static_cast<const volatile gles2::cmds::
                        ScheduleCALayerInUseQueryCHROMIUMImmediate*>(cmd_data);
   GLsizei count = static_cast<GLsizei>(c.count);
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLuint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLuint* textures = GetImmediateDataAs<volatile const GLuint*>(
       c, data_size, immediate_data_size);
+  if (textures == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoScheduleCALayerInUseQueryCHROMIUM(count, textures);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleCommitOverlayPlanesCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 36 matching lines @@
   GLenum matrixMode = static_cast<GLenum>(c.matrixMode);
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* m = GetImmediateDataAs<volatile const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (m == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoMatrixLoadfCHROMIUM(matrixMode, m);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleMatrixLoadIdentityCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 91 matching lines @@
   uint32_t data_size;
   if (!GLES2Util::ComputeDataSize(1, sizeof(GLfloat), 16, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLfloat* transform =
       GetImmediateDataAs<volatile const GLfloat*>(c, data_size,
                                                   immediate_data_size);
+  if (transform == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoUniformMatrix4fvStreamTextureMatrixCHROMIUM(
       location, transpose, transform);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::HandleOverlayPromotionHintCHROMIUM(
     uint32_t immediate_data_size,
@@ skipping 25 matching lines @@
   uint32_t data_size = 0;
   if (count >= 0 &&
       !GLES2Util::ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   volatile const GLint* rects = GetImmediateDataAs<volatile const GLint*>(
       c, data_size, immediate_data_size);
+  if (rects == nullptr) {
+    return error::kOutOfBounds;
+  }
   error::Error error = DoSwapBuffersWithBoundsCHROMIUM(count, rects);
   if (error != error::kNoError) {
     return error;
   }
   return error::kNoError;
 }
 
 }  // namespace gles2
 }  // namespace gpu