Remove string-getting methods 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 35 matching lines @@
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/ANGLEInstancedArrays.h"
 #include "modules/webgl/CHROMIUMSubscribeUniform.h"
 #include "modules/webgl/CHROMIUMValuebuffer.h"
 #include "modules/webgl/EXTBlendMinMax.h"
 #include "modules/webgl/EXTFragDepth.h"
 #include "modules/webgl/EXTShaderTextureLOD.h"
 #include "modules/webgl/EXTTextureFilterAnisotropic.h"
+#include "modules/webgl/GLStringQuery.h"
 #include "modules/webgl/OESElementIndexUint.h"
 #include "modules/webgl/OESStandardDerivatives.h"
 #include "modules/webgl/OESTextureFloat.h"
 #include "modules/webgl/OESTextureFloatLinear.h"
 #include "modules/webgl/OESTextureHalfFloat.h"
 #include "modules/webgl/OESTextureHalfFloatLinear.h"
 #include "modules/webgl/OESVertexArrayObject.h"
 #include "modules/webgl/WebGLActiveInfo.h"
 #include "modules/webgl/WebGLBuffer.h"
 #include "modules/webgl/WebGLCompressedTextureASTC.h"
@@ skipping 2203 matching lines @@
         return;
     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))
+    LChar* namePtr;
+    RefPtr<StringImpl> nameImpl = StringImpl::createUninitialized(maxNameLength, namePtr);
+    GLsizei length = 0;
+    GLint size = -1;
+    GLenum type = 0;
+    contextGL()->GetActiveAttrib(programId, index, maxNameLength, &length, &size, &type, reinterpret_cast<GLchar*>(namePtr));
+    if (size < 0)
         return nullptr;
-    return WebGLActiveInfo::create(info.name, info.type, info.size);
+    return WebGLActiveInfo::create(nameImpl->substring(0, length), type, 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(programId, index, info))
+    LChar* namePtr;
+    RefPtr<StringImpl> nameImpl = StringImpl::createUninitialized(maxNameLength, namePtr);
+    GLsizei length = 0;
+    GLint size = -1;
+    GLenum type = 0;
+    contextGL()->GetActiveUniform(programId, index, maxNameLength, &length, &size, &type, reinterpret_cast<GLchar*>(namePtr));
+    if (size < 0)
         return nullptr;
-    return WebGLActiveInfo::create(info.name, info.type, info.size);
+    return WebGLActiveInfo::create(nameImpl->substring(0, length), type, size);
 }
 
 Nullable<HeapVector<Member<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return nullptr;
 
     HeapVector<Member<WebGLShader>> shaderObjects;
     const GLenum shaderType[] = {
         GL_VERTEX_SHADER,
@@ skipping 510 matching lines @@
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getProgramParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 String WebGLRenderingContextBase::getProgramInfoLog(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getProgramInfoLog", program))
         return String();
-    return ensureNotNull(webContext()->getProgramInfoLog(objectOrZero(program)));
+    GLStringQuery query(contextGL());
+    return query.Run<GLStringQuery::ProgramInfoLog>(objectNonZero(program));
 }
 
 ScriptValue WebGLRenderingContextBase::getRenderbufferParameter(ScriptState* scriptState, GLenum target, GLenum pname)
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
     if (target != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "getRenderbufferParameter", "invalid target");
         return ScriptValue::createNull(scriptState);
     }
@@ skipping 46 matching lines @@
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("getShaderInfoLog", shader))
         return String();
-    return ensureNotNull(webContext()->getShaderInfoLog(objectOrZero(shader)));
+    GLStringQuery query(contextGL());
+    return query.Run<GLStringQuery::ShaderInfoLog>(objectNonZero(shader));
 }
 
 WebGLShaderPrecisionFormat* WebGLRenderingContextBase::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
 {
     if (isContextLost())
         return nullptr;
     switch (shaderType) {
     case GL_VERTEX_SHADER:
     case GL_FRAGMENT_SHADER:
         break;
@@ skipping 81 matching lines @@
 ScriptValue WebGLRenderingContextBase::getUniform(ScriptState* scriptState, WebGLProgram* program, const WebGLUniformLocation* uniformLocation)
 {
     if (isContextLost() || !validateWebGLObject("getUniform", program))
         return ScriptValue::createNull(scriptState);
     if (!uniformLocation || 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);
+    if (maxNameLength < 0)
+        return ScriptValue::createNull(scriptState);
+    if (maxNameLength == 0) {
+        synthesizeGLError(GL_INVALID_VALUE, "getUniform", "no active uniforms exist");
+        return ScriptValue::createNull(scriptState);
+    }
+
     // FIXME: make this more efficient using WebGLUniformLocation and caching types in it
     GLint activeUniforms = 0;
-    contextGL()->GetProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
+    contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORMS, &activeUniforms);
     for (GLint i = 0; i < activeUniforms; i++) {
-        WebGraphicsContext3D::ActiveInfo info;
-        if (!webContext()->getActiveUniform(objectOrZero(program), i, info))
+        LChar* namePtr;
+        RefPtr<StringImpl> nameImpl = StringImpl::createUninitialized(maxNameLength, namePtr);
+        GLsizei length = 0;
+        GLint size = -1;
+        GLenum type = 0;
+        contextGL()->GetActiveUniform(programId, i, maxNameLength, &length, &size, &type, reinterpret_cast<GLchar*>(namePtr));
+        if (size < 0)
             return ScriptValue::createNull(scriptState);
-        String name = info.name;
+        String name(nameImpl->substring(0, length));
         StringBuilder nameBuilder;
         // Strip "[0]" from the name if it's an array.
-        if (info.size > 1 && name.endsWith("[0]"))
-            info.name = name.left(name.length() - 3);
+        if (size > 1 && name.endsWith("[0]"))
+            name = name.left(name.length() - 3);
         // If it's an array, we need to iterate through each element, appending "[index]" to the name.
-        for (GLint index = 0; index < info.size; ++index) {
+        for (GLint index = 0; index < size; ++index) {
             nameBuilder.clear();
-            nameBuilder.append(info.name);
-            if (info.size > 1 && index >= 1) {
+            nameBuilder.append(name);
+            if (size > 1 && index >= 1) {
                 nameBuilder.append('[');
                 nameBuilder.appendNumber(index);
                 nameBuilder.append(']');
             }
             // Now need to look this up by name again to find its location
             GLint loc = contextGL()->GetUniformLocation(objectOrZero(program), nameBuilder.toString().utf8().data());
             if (loc == location) {
                 // Found it. Use the type in the ActiveInfo to determine the return type.
                 GLenum baseType;
                 unsigned length;
-                switch (info.type) {
+                switch (type) {
                 case GL_BOOL:
                     baseType = GL_BOOL;
                     length = 1;
                     break;
                 case GL_BOOL_VEC2:
                     baseType = GL_BOOL;
                     length = 2;
                     break;
                 case GL_BOOL_VEC3:
                     baseType = GL_BOOL;
@@ skipping 52 matching lines @@
                     baseType = GL_INT;
                     length = 1;
                     break;
                 default:
                     if (!isWebGL2OrHigher()) {
                         // Can't handle this type
                         synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unhandled type");
                         return ScriptValue::createNull(scriptState);
                     }
                     // handle GLenums for WebGL 2.0 or higher
-                    switch (info.type) {
+                    switch (type) {
                     case GL_UNSIGNED_INT:
                         baseType = GL_UNSIGNED_INT;
                         length = 1;
                         break;
                     case GL_UNSIGNED_INT_VEC2:
                         baseType = GL_UNSIGNED_INT;
                         length = 2;
                         break;
                     case GL_UNSIGNED_INT_VEC3:
                         baseType = GL_UNSIGNED_INT;
@@ skipping 3190 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink