Remove getError() and synthesizeGLError() from WebGraphicsContext3D.

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 2278 matching lines @@
     if (!validateTextureBinding("generateMipmap", target))
         return;
     contextGL()->GenerateMipmap(target);
 }
 
 WebGLActiveInfo* WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
     WebGraphicsContext3D::ActiveInfo info;
+    GLuint programId = objectNonZero(program);
+    GLint maxNameLength = -1;
+    contextGL()->GetProgramiv(programId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength);
+    if (maxNameLength < 0)
+        return nullptr;
+    if (maxNameLength == 0) {
+        synthesizeGLError(GL_INVALID_VALUE, "getActiveAttrib", "no active attributes exist");
+        return nullptr;
+    }
     if (!webContext()->getActiveAttrib(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 WebGLActiveInfo* WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
+    GLuint programId = objectNonZero(program);
+    GLint maxNameLength = -1;
+    contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
+    if (maxNameLength < 0)
+        return nullptr;
+    if (maxNameLength == 0) {
+        synthesizeGLError(GL_INVALID_VALUE, "getActiveUniform", "no active uniforms exist");
+        return nullptr;
+    }
     WebGraphicsContext3D::ActiveInfo info;
-    if (!webContext()->getActiveUniform(objectOrZero(program), index, info))
+    if (!webContext()->getActiveUniform(programId, index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 Nullable<HeapVector<Member<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return nullptr;
 
     HeapVector<Member<WebGLShader>> shaderObjects;
@@ skipping 12 matching lines @@
 GLint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("getAttribLocation", program))
         return -1;
     if (!validateLocationLength("getAttribLocation", name))
         return -1;
     if (!validateString("getAttribLocation", name))
         return -1;
     if (isPrefixReserved(name))
         return -1;
-    if (!program->linkStatus()) {
+    if (!program->linkStatus(this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "getAttribLocation", "program not linked");
         return 0;
     }
     return contextGL()->GetAttribLocation(objectOrZero(program), name.utf8().data());
 }
 
 bool WebGLRenderingContextBase::validateBufferTarget(const char* functionName, GLenum target)
 {
     switch (target) {
     case GL_ARRAY_BUFFER:
@@ skipping 41 matching lines @@
     WebGraphicsContext3D::Attributes attrs = drawingBuffer()->getActualAttributes();
     if (m_requestedAttributes.depth() && !attrs.depth)
         result.get().setDepth(false);
     if (m_requestedAttributes.stencil() && !attrs.stencil)
         result.get().setStencil(false);
     result.get().setAntialias(drawingBuffer()->multisample());
 }
 
 GLenum WebGLRenderingContextBase::getError()
 {
-    if (m_lostContextErrors.size()) {
-        GLenum err = m_lostContextErrors.first();
+    if (!m_lostContextErrors.isEmpty()) {
+        GLenum error = m_lostContextErrors.first();
         m_lostContextErrors.remove(0);
-        return err;
+        return error;
     }
 
     if (isContextLost())
         return GL_NO_ERROR;
 
-    return webContext()->getError();
+    if (!m_syntheticErrors.isEmpty()) {
+        GLenum error = m_syntheticErrors.first();
+        m_syntheticErrors.remove(0);
+        return error;
+    }
+
+    return contextGL()->GetError();
 }
 
 const char* const* WebGLRenderingContextBase::ExtensionTracker::prefixes() const
 {
     static const char* const unprefixed[] = { "", 0, };
     return m_prefixes ? m_prefixes : unprefixed;
 }
 
 bool WebGLRenderingContextBase::ExtensionTracker::matchesNameWithPrefixes(const String& name) const
 {
@@ skipping 375 matching lines @@
         return ScriptValue::createNull(scriptState);
 
     GLint value = 0;
     switch (pname) {
     case GL_DELETE_STATUS:
         return WebGLAny(scriptState, program->isDeleted());
     case GL_VALIDATE_STATUS:
         contextGL()->GetProgramiv(objectOrZero(program), pname, &value);
         return WebGLAny(scriptState, static_cast<bool>(value));
     case GL_LINK_STATUS:
-        return WebGLAny(scriptState, program->linkStatus());
+        return WebGLAny(scriptState, program->linkStatus(this));
     case GL_ACTIVE_UNIFORM_BLOCKS:
     case GL_TRANSFORM_FEEDBACK_VARYINGS:
         if (!isWebGL2OrHigher()) {
             synthesizeGLError(GL_INVALID_ENUM, "getProgramParameter", "invalid parameter name");
             return ScriptValue::createNull(scriptState);
         }
     case GL_ATTACHED_SHADERS:
     case GL_ACTIVE_ATTRIBUTES:
     case GL_ACTIVE_UNIFORMS:
         contextGL()->GetProgramiv(objectOrZero(program), pname, &value);
@@ skipping 381 matching lines @@
 WebGLUniformLocation* WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("getUniformLocation", program))
         return nullptr;
     if (!validateLocationLength("getUniformLocation", name))
         return nullptr;
     if (!validateString("getUniformLocation", name))
         return nullptr;
     if (isPrefixReserved(name))
         return nullptr;
-    if (!program->linkStatus()) {
+    if (!program->linkStatus(this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "getUniformLocation", "program not linked");
         return nullptr;
     }
     GLint uniformLocation = contextGL()->GetUniformLocation(objectOrZero(program), name.utf8().data());
     if (uniformLocation == -1)
         return nullptr;
     return WebGLUniformLocation::create(program, uniformLocation);
 }
 
 ScriptValue WebGLRenderingContextBase::getVertexAttrib(ScriptState* scriptState, GLuint index, GLenum pname)
@@ skipping 1550 matching lines @@
     contextGL()->UniformMatrix4fv(location->location(), v.size() >> 4, transpose, v.data());
 }
 
 void WebGLRenderingContextBase::useProgram(ScriptState* scriptState, WebGLProgram* program)
 {
     bool deleted;
     if (!checkObjectToBeBound("useProgram", program, deleted))
         return;
     if (deleted)
         program = 0;
-    if (program && !program->linkStatus()) {
+    if (program && !program->linkStatus(this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "program not valid");
         return;
     }
 
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "transform feedback is active and not paused");
         return;
     }
 
     if (m_currentProgram != program) {
@@ skipping 1262 matching lines @@
 } // namespace
 
 void WebGLRenderingContextBase::synthesizeGLError(GLenum error, const char* functionName, const char* description, ConsoleDisplayPreference display)
 {
     String errorType = GetErrorString(error);
     if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {
         String message = String("WebGL: ") + errorType +  ": " + String(functionName) + ": " + String(description);
         printGLErrorToConsole(message);
     }
     if (!isContextLost()) {
-        webContext()->synthesizeGLError(error);
+        if (!m_syntheticErrors.contains(error))
+            m_syntheticErrors.append(error);
     } else {
-        if (m_lostContextErrors.find(error) == WTF::kNotFound)
+        if (!m_lostContextErrors.contains(error))
             m_lostContextErrors.append(error);
     }
     InspectorInstrumentation::didFireWebGLError(canvas(), errorType);
 }
 
 void WebGLRenderingContextBase::emitGLWarning(const char* functionName, const char* description)
 {
     if (m_synthesizedErrorsToConsole) {
         String message = String("WebGL: ") + String(functionName) + ": " + String(description);
         printGLErrorToConsole(message);
@@ skipping 218 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink