Change WebGL API arg nullable behavior.

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1841 matching lines @@
     return;
   }
   bufferDataImpl(target, data->byteLength(), data->data(), usage);
 }
 
 void WebGLRenderingContextBase::bufferData(GLenum target,
                                            DOMArrayBufferView* data,
                                            GLenum usage) {
   if (isContextLost())
     return;
-  if (!data) {
-    synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
-    return;
-  }
+  DCHECK(data);
   bufferDataImpl(target, data->byteLength(), data->baseAddress(), usage);
 }
 
 void WebGLRenderingContextBase::bufferSubDataImpl(GLenum target,
                                                   long long offset,
                                                   GLsizeiptr size,
                                                   const void* data) {
   WebGLBuffer* buffer = validateBufferDataTarget("bufferSubData", target);
   if (!buffer)
     return;
   if (!validateValueFitNonNegInt32("bufferSubData", "offset", offset))
     return;
   if (!data)
     return;
   if (offset + static_cast<long long>(size) > buffer->getSize()) {
     synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "buffer overflow");
     return;
   }
 
   contextGL()->BufferSubData(target, static_cast<GLintptr>(offset), size, data);
 }
 
 void WebGLRenderingContextBase::bufferSubData(GLenum target,
                                               long long offset,
                                               DOMArrayBuffer* data) {
   if (isContextLost())
     return;
-  if (!data) {
-    synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "no data");
-    return;
-  }
+  DCHECK(data);
   bufferSubDataImpl(target, offset, data->byteLength(), data->data());
 }
 
 void WebGLRenderingContextBase::bufferSubData(
     GLenum target,
     long long offset,
     const FlexibleArrayBufferView& data) {
   if (isContextLost())
     return;
-  if (!data) {
-    synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "no data");
-    return;
-  }
+  DCHECK(data);
   bufferSubDataImpl(target, offset, data.byteLength(),
                     data.baseAddressMaybeOnStack());
 }
 
 bool WebGLRenderingContextBase::validateFramebufferTarget(GLenum target) {
   if (target == GL_FRAMEBUFFER)
     return true;
   return false;
 }
 
@@ skipping 470 matching lines @@
     synthesizeGLError(GL_INVALID_OPERATION, functionName,
                       "no valid shader program in use");
     return false;
   }
 
   return true;
 }
 
 bool WebGLRenderingContextBase::validateWebGLObject(const char* functionName,
                                                     WebGLObject* object) {
-  if (!object || !object->hasObject()) {
+  DCHECK(object);
+  if (!object->hasObject()) {
     synthesizeGLError(GL_INVALID_VALUE, functionName,
                       "no object or object deleted");
     return false;
   }
   if (!object->validate(contextGroup(), this)) {
     synthesizeGLError(GL_INVALID_OPERATION, functionName,
                       "object does not belong to this context");
     return false;
   }
   return true;
@@ skipping 1003 matching lines @@
       return ScriptValue::createNull(scriptState);
   }
 }
 
 ScriptValue WebGLRenderingContextBase::getUniform(
     ScriptState* scriptState,
     WebGLProgram* program,
     const WebGLUniformLocation* uniformLocation) {
   if (isContextLost() || !validateWebGLObject("getUniform", program))
     return ScriptValue::createNull(scriptState);
-  if (!uniformLocation || uniformLocation->program() != program) {
+  DCHECK(uniformLocation);
+  if (uniformLocation->program() != program) {
     synthesizeGLError(GL_INVALID_OPERATION, "getUniform",
                       "no uniformlocation or not valid for this program");
     return ScriptValue::createNull(scriptState);
   }
   GLint location = uniformLocation->location();
 
   GLuint programId = objectNonZero(program);
   GLint maxNameLength = -1;
   contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH,
                             &maxNameLength);
@@ skipping 1250 matching lines @@
     GLenum format,
     GLenum type,
     GLsizei depth,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     ImageData* pixels) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
-  if (!pixels) {
-    synthesizeGLError(GL_INVALID_VALUE, funcName, "no image data");
-    return;
-  }
+  DCHECK(pixels);
   if (pixels->data()->bufferBase()->isNeutered()) {
     synthesizeGLError(GL_INVALID_VALUE, funcName,
                       "The source data has been neutered.");
     return;
   }
   if (!validateTexImageBinding(funcName, functionID, target))
     return;
   TexImageFunctionType functionType;
   if (functionID == TexImage2D)
     functionType = TexImage;
@@ skipping 2920 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink