Add m-esr52 at 52.6.0

1 files changed, 1645 insertions, 0 deletions

diff --git a/dom/canvas/WebGLProgram.cpp b/dom/canvas/WebGLProgram.cpp
new file mode 100644
index 000000000..fa7997f22
--- /dev/null
+++ b/dom/canvas/WebGLProgram.cpp
@@ -0,0 +1,1645 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGLProgram.h"
+
+#include "GLContext.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/dom/WebGL2RenderingContextBinding.h"
+#include "mozilla/dom/WebGLRenderingContextBinding.h"
+#include "mozilla/RefPtr.h"
+#include "nsPrintfCString.h"
+#include "WebGLActiveInfo.h"
+#include "WebGLContext.h"
+#include "WebGLShader.h"
+#include "WebGLTransformFeedback.h"
+#include "WebGLUniformLocation.h"
+#include "WebGLValidateStrings.h"
+
+namespace mozilla {
+
+/* If `name`: "foo[3]"
+ * Then returns true, with
+ *     `out_baseName`: "foo"
+ *     `out_isArray`: true
+ *     `out_index`: 3
+ *
+ * If `name`: "foo"
+ * Then returns true, with
+ *     `out_baseName`: "foo"
+ *     `out_isArray`: false
+ *     `out_index`: 0
+ */
+static bool
+ParseName(const nsCString& name, nsCString* const out_baseName,
+          bool* const out_isArray, size_t* const out_arrayIndex)
+{
+    int32_t indexEnd = name.RFind("]");
+    if (indexEnd == -1 ||
+        (uint32_t)indexEnd != name.Length() - 1)
+    {
+        *out_baseName = name;
+        *out_isArray = false;
+        *out_arrayIndex = 0;
+        return true;
+    }
+
+    int32_t indexOpenBracket = name.RFind("[");
+    if (indexOpenBracket == -1)
+        return false;
+
+    uint32_t indexStart = indexOpenBracket + 1;
+    uint32_t indexLen = indexEnd - indexStart;
+    if (indexLen == 0)
+        return false;
+
+    const nsAutoCString indexStr(Substring(name, indexStart, indexLen));
+
+    nsresult errorcode;
+    int32_t indexNum = indexStr.ToInteger(&errorcode);
+    if (NS_FAILED(errorcode))
+        return false;
+
+    if (indexNum < 0)
+        return false;
+
+    *out_baseName = StringHead(name, indexOpenBracket);
+    *out_isArray = true;
+    *out_arrayIndex = indexNum;
+    return true;
+}
+
+static void
+AssembleName(const nsCString& baseName, bool isArray, size_t arrayIndex,
+             nsCString* const out_name)
+{
+    *out_name = baseName;
+    if (isArray) {
+        out_name->Append('[');
+        out_name->AppendInt(uint64_t(arrayIndex));
+        out_name->Append(']');
+    }
+}
+
+////
+
+static GLenum
+AttribBaseType(GLenum attribType)
+{
+    switch (attribType) {
+    case LOCAL_GL_FLOAT:
+    case LOCAL_GL_FLOAT_VEC2:
+    case LOCAL_GL_FLOAT_VEC3:
+    case LOCAL_GL_FLOAT_VEC4:
+
+    case LOCAL_GL_FLOAT_MAT2:
+    case LOCAL_GL_FLOAT_MAT2x3:
+    case LOCAL_GL_FLOAT_MAT2x4:
+
+    case LOCAL_GL_FLOAT_MAT3x2:
+    case LOCAL_GL_FLOAT_MAT3:
+    case LOCAL_GL_FLOAT_MAT3x4:
+
+    case LOCAL_GL_FLOAT_MAT4x2:
+    case LOCAL_GL_FLOAT_MAT4x3:
+    case LOCAL_GL_FLOAT_MAT4:
+        return LOCAL_GL_FLOAT;
+
+    case LOCAL_GL_INT:
+    case LOCAL_GL_INT_VEC2:
+    case LOCAL_GL_INT_VEC3:
+    case LOCAL_GL_INT_VEC4:
+        return LOCAL_GL_INT;
+
+    case LOCAL_GL_UNSIGNED_INT:
+    case LOCAL_GL_UNSIGNED_INT_VEC2:
+    case LOCAL_GL_UNSIGNED_INT_VEC3:
+    case LOCAL_GL_UNSIGNED_INT_VEC4:
+        return LOCAL_GL_UNSIGNED_INT;
+
+    default:
+        MOZ_ASSERT(false, "unexpected attrib elemType");
+        return 0;
+    }
+}
+
+////
+
+/*static*/ const webgl::UniformInfo::TexListT*
+webgl::UniformInfo::GetTexList(WebGLActiveInfo* activeInfo)
+{
+    const auto& webgl = activeInfo->mWebGL;
+
+    switch (activeInfo->mElemType) {
+    case LOCAL_GL_SAMPLER_2D:
+    case LOCAL_GL_SAMPLER_2D_SHADOW:
+    case LOCAL_GL_INT_SAMPLER_2D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
+        return &webgl->mBound2DTextures;
+
+    case LOCAL_GL_SAMPLER_CUBE:
+    case LOCAL_GL_SAMPLER_CUBE_SHADOW:
+    case LOCAL_GL_INT_SAMPLER_CUBE:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
+        return &webgl->mBoundCubeMapTextures;
+
+    case LOCAL_GL_SAMPLER_3D:
+    case LOCAL_GL_INT_SAMPLER_3D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
+        return &webgl->mBound3DTextures;
+
+    case LOCAL_GL_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
+    case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+        return &webgl->mBound2DArrayTextures;
+
+    default:
+        return nullptr;
+    }
+}
+
+webgl::UniformInfo::UniformInfo(WebGLActiveInfo* activeInfo)
+    : mActiveInfo(activeInfo)
+    , mSamplerTexList(GetTexList(activeInfo))
+{
+    if (mSamplerTexList) {
+        mSamplerValues.assign(mActiveInfo->mElemCount, 0);
+    }
+}
+
+//////////
+
+//#define DUMP_SHADERVAR_MAPPINGS
+
+static already_AddRefed<const webgl::LinkedProgramInfo>
+QueryProgramInfo(WebGLProgram* prog, gl::GLContext* gl)
+{
+    WebGLContext* const webgl = prog->mContext;
+
+    RefPtr<webgl::LinkedProgramInfo> info(new webgl::LinkedProgramInfo(prog));
+
+    GLuint maxAttribLenWithNull = 0;
+    gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
+                      (GLint*)&maxAttribLenWithNull);
+    if (maxAttribLenWithNull < 1)
+        maxAttribLenWithNull = 1;
+
+    GLuint maxUniformLenWithNull = 0;
+    gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH,
+                      (GLint*)&maxUniformLenWithNull);
+    if (maxUniformLenWithNull < 1)
+        maxUniformLenWithNull = 1;
+
+    GLuint maxUniformBlockLenWithNull = 0;
+    if (gl->IsSupported(gl::GLFeature::uniform_buffer_object)) {
+        gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH,
+                          (GLint*)&maxUniformBlockLenWithNull);
+        if (maxUniformBlockLenWithNull < 1)
+            maxUniformBlockLenWithNull = 1;
+    }
+
+    GLuint maxTransformFeedbackVaryingLenWithNull = 0;
+    if (gl->IsSupported(gl::GLFeature::transform_feedback2)) {
+        gl->fGetProgramiv(prog->mGLName, LOCAL_GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,
+                          (GLint*)&maxTransformFeedbackVaryingLenWithNull);
+        if (maxTransformFeedbackVaryingLenWithNull < 1)
+            maxTransformFeedbackVaryingLenWithNull = 1;
+    }
+
+    // Attribs (can't be arrays)
+
+    GLuint numActiveAttribs = 0;
+    gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_ATTRIBUTES,
+                      (GLint*)&numActiveAttribs);
+
+    for (GLuint i = 0; i < numActiveAttribs; i++) {
+        nsAutoCString mappedName;
+        mappedName.SetLength(maxAttribLenWithNull - 1);
+
+        GLsizei lengthWithoutNull = 0;
+        GLint elemCount = 0; // `size`
+        GLenum elemType = 0; // `type`
+        gl->fGetActiveAttrib(prog->mGLName, i, mappedName.Length()+1, &lengthWithoutNull,
+                             &elemCount, &elemType, mappedName.BeginWriting());
+        GLenum error = gl->fGetError();
+        if (error != LOCAL_GL_NO_ERROR) {
+            gfxCriticalNote << "Failed to do glGetActiveAttrib: " << error;
+        }
+
+        mappedName.SetLength(lengthWithoutNull);
+
+        ////
+
+        nsCString userName;
+        if (!prog->FindAttribUserNameByMappedName(mappedName, &userName)) {
+            userName = mappedName;
+        }
+
+        ///////
+
+        GLint loc = gl->fGetAttribLocation(prog->mGLName,
+                                           mappedName.BeginReading());
+        if (gl->WorkAroundDriverBugs() &&
+            mappedName.EqualsIgnoreCase("gl_", 3))
+        {
+            // Bug 1328559: Appears problematic on ANGLE and OSX, but not Linux or Win+GL.
+            loc = -1;
+        }
+#ifdef DUMP_SHADERVAR_MAPPINGS
+        printf_stderr("[attrib %u/%u] @%i %s->%s\n", i, numActiveAttribs, loc,
+                      userName.BeginReading(), mappedName.BeginReading());
+#endif
+        MOZ_ASSERT_IF(mappedName.EqualsIgnoreCase("gl_", 3), loc == -1);
+
+        ///////
+
+        const bool isArray = false;
+        const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(webgl, elemCount,
+                                                                       elemType, isArray,
+                                                                       userName,
+                                                                       mappedName);
+        const GLenum baseType = AttribBaseType(elemType);
+        const webgl::AttribInfo attrib = {activeInfo, loc, baseType};
+        info->attribs.push_back(attrib);
+    }
+
+    // Uniforms (can be basically anything)
+
+    const bool needsCheckForArrays = gl->WorkAroundDriverBugs();
+
+    GLuint numActiveUniforms = 0;
+    gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORMS,
+                      (GLint*)&numActiveUniforms);
+
+    for (GLuint i = 0; i < numActiveUniforms; i++) {
+        nsAutoCString mappedName;
+        mappedName.SetLength(maxUniformLenWithNull - 1);
+
+        GLsizei lengthWithoutNull = 0;
+        GLint elemCount = 0; // `size`
+        GLenum elemType = 0; // `type`
+        gl->fGetActiveUniform(prog->mGLName, i, mappedName.Length()+1, &lengthWithoutNull,
+                              &elemCount, &elemType, mappedName.BeginWriting());
+
+        mappedName.SetLength(lengthWithoutNull);
+
+        ///////
+
+        nsAutoCString baseMappedName;
+        bool isArray;
+        size_t arrayIndex;
+        if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
+            MOZ_CRASH("GFX: Failed to parse `mappedName` received from driver.");
+
+        // Note that for good drivers, `isArray` should already be correct.
+        // However, if FindUniform succeeds, it will be validator-guaranteed correct.
+
+        ///////
+
+        nsAutoCString baseUserName;
+        if (!prog->FindUniformByMappedName(baseMappedName, &baseUserName, &isArray)) {
+            // Validator likely missing.
+            baseUserName = baseMappedName;
+
+            if (needsCheckForArrays && !isArray) {
+                // By GLES 3, GetUniformLocation("foo[0]") should return -1 if `foo` is
+                // not an array. Our current linux Try slaves return the location of `foo`
+                // anyways, though.
+                std::string mappedNameStr = baseMappedName.BeginReading();
+                mappedNameStr += "[0]";
+
+                GLint loc = gl->fGetUniformLocation(prog->mGLName, mappedNameStr.c_str());
+                if (loc != -1)
+                    isArray = true;
+            }
+        }
+
+        ///////
+
+#ifdef DUMP_SHADERVAR_MAPPINGS
+        printf_stderr("[uniform %u/%u] %s->%s\n", i, numActiveUniforms,
+                      baseUserName.BeginReading(), mappedName.BeginReading());
+#endif
+
+        ///////
+
+        const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(webgl, elemCount,
+                                                                       elemType, isArray,
+                                                                       baseUserName,
+                                                                       baseMappedName);
+
+        auto* uniform = new webgl::UniformInfo(activeInfo);
+        info->uniforms.push_back(uniform);
+
+        if (uniform->mSamplerTexList) {
+            info->uniformSamplers.push_back(uniform);
+        }
+    }
+
+    // Uniform Blocks (can be arrays, but can't contain sampler types)
+
+    if (gl->IsSupported(gl::GLFeature::uniform_buffer_object)) {
+        GLuint numActiveUniformBlocks = 0;
+        gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORM_BLOCKS,
+                          (GLint*)&numActiveUniformBlocks);
+
+        for (GLuint i = 0; i < numActiveUniformBlocks; i++) {
+            nsAutoCString mappedName;
+            mappedName.SetLength(maxUniformBlockLenWithNull - 1);
+
+            GLint lengthWithoutNull;
+            gl->fGetActiveUniformBlockiv(prog->mGLName, i, LOCAL_GL_UNIFORM_BLOCK_NAME_LENGTH, &lengthWithoutNull);
+            gl->fGetActiveUniformBlockName(prog->mGLName, i, maxUniformBlockLenWithNull, &lengthWithoutNull, mappedName.BeginWriting());
+            mappedName.SetLength(lengthWithoutNull);
+
+            ////
+
+            nsCString userName;
+            if (!prog->UnmapUniformBlockName(mappedName, &userName))
+                continue;
+
+#ifdef DUMP_SHADERVAR_MAPPINGS
+            printf_stderr("[uniform block %u/%u] %s->%s\n", i, numActiveUniformBlocks,
+                          userName.BeginReading(), mappedName.BeginReading());
+#endif
+
+            ////
+
+            GLuint dataSize = 0;
+            gl->fGetActiveUniformBlockiv(prog->mGLName, i,
+                                         LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE,
+                                         (GLint*)&dataSize);
+
+
+            auto* block = new webgl::UniformBlockInfo(webgl, userName, mappedName,
+                                                      dataSize);
+            info->uniformBlocks.push_back(block);
+        }
+    }
+
+    // Transform feedback varyings (can be arrays)
+
+    if (gl->IsSupported(gl::GLFeature::transform_feedback2)) {
+        GLuint numTransformFeedbackVaryings = 0;
+        gl->fGetProgramiv(prog->mGLName, LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS,
+                          (GLint*)&numTransformFeedbackVaryings);
+
+        for (GLuint i = 0; i < numTransformFeedbackVaryings; i++) {
+            nsAutoCString mappedName;
+            mappedName.SetLength(maxTransformFeedbackVaryingLenWithNull - 1);
+
+            GLint lengthWithoutNull;
+            GLsizei elemCount;
+            GLenum elemType;
+            gl->fGetTransformFeedbackVarying(prog->mGLName, i,
+                                             maxTransformFeedbackVaryingLenWithNull,
+                                             &lengthWithoutNull, &elemCount, &elemType,
+                                             mappedName.BeginWriting());
+            mappedName.SetLength(lengthWithoutNull);
+
+            ////
+
+            nsAutoCString baseMappedName;
+            bool isArray;
+            size_t arrayIndex;
+            if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
+                MOZ_CRASH("GFX: Failed to parse `mappedName` received from driver.");
+
+            nsAutoCString baseUserName;
+            if (!prog->FindVaryingByMappedName(mappedName, &baseUserName, &isArray)) {
+                baseUserName = baseMappedName;
+            }
+
+            ////
+
+#ifdef DUMP_SHADERVAR_MAPPINGS
+            printf_stderr("[transform feedback varying %u/%u] %s->%s\n", i,
+                          numTransformFeedbackVaryings, baseUserName.BeginReading(),
+                          mappedName.BeginReading());
+#endif
+
+            const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(webgl,
+                                                                           elemCount,
+                                                                           elemType,
+                                                                           isArray,
+                                                                           baseUserName,
+                                                                           mappedName);
+            info->transformFeedbackVaryings.push_back(activeInfo);
+        }
+    }
+
+    // Frag outputs
+
+    prog->EnumerateFragOutputs(info->fragDataMap);
+
+    return info.forget();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+webgl::LinkedProgramInfo::LinkedProgramInfo(WebGLProgram* prog)
+    : prog(prog)
+    , transformFeedbackBufferMode(prog->mNextLink_TransformFeedbackBufferMode)
+{ }
+
+webgl::LinkedProgramInfo::~LinkedProgramInfo()
+{
+    for (auto& cur : uniforms) {
+        delete cur;
+    }
+    for (auto& cur : uniformBlocks) {
+        delete cur;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WebGLProgram
+
+static GLuint
+CreateProgram(gl::GLContext* gl)
+{
+    gl->MakeCurrent();
+    return gl->fCreateProgram();
+}
+
+WebGLProgram::WebGLProgram(WebGLContext* webgl)
+    : WebGLRefCountedObject(webgl)
+    , mGLName(CreateProgram(webgl->GL()))
+    , mNumActiveTFOs(0)
+    , mNextLink_TransformFeedbackBufferMode(LOCAL_GL_INTERLEAVED_ATTRIBS)
+{
+    mContext->mPrograms.insertBack(this);
+}
+
+WebGLProgram::~WebGLProgram()
+{
+    DeleteOnce();
+}
+
+void
+WebGLProgram::Delete()
+{
+    gl::GLContext* gl = mContext->GL();
+
+    gl->MakeCurrent();
+    gl->fDeleteProgram(mGLName);
+
+    mVertShader = nullptr;
+    mFragShader = nullptr;
+
+    mMostRecentLinkInfo = nullptr;
+
+    LinkedListElement<WebGLProgram>::removeFrom(mContext->mPrograms);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// GL funcs
+
+void
+WebGLProgram::AttachShader(WebGLShader* shader)
+{
+    WebGLRefPtr<WebGLShader>* shaderSlot;
+    switch (shader->mType) {
+    case LOCAL_GL_VERTEX_SHADER:
+        shaderSlot = &mVertShader;
+        break;
+    case LOCAL_GL_FRAGMENT_SHADER:
+        shaderSlot = &mFragShader;
+        break;
+    default:
+        mContext->ErrorInvalidOperation("attachShader: Bad type for shader.");
+        return;
+    }
+
+    if (*shaderSlot) {
+        if (shader == *shaderSlot) {
+            mContext->ErrorInvalidOperation("attachShader: `shader` is already attached.");
+        } else {
+            mContext->ErrorInvalidOperation("attachShader: Only one of each type of"
+                                            " shader may be attached to a program.");
+        }
+        return;
+    }
+
+    *shaderSlot = shader;
+
+    mContext->MakeContextCurrent();
+    mContext->gl->fAttachShader(mGLName, shader->mGLName);
+}
+
+void
+WebGLProgram::BindAttribLocation(GLuint loc, const nsAString& name)
+{
+    if (!ValidateGLSLVariableName(name, mContext, "bindAttribLocation"))
+        return;
+
+    if (loc >= mContext->MaxVertexAttribs()) {
+        mContext->ErrorInvalidValue("bindAttribLocation: `location` must be less than"
+                                    " MAX_VERTEX_ATTRIBS.");
+        return;
+    }
+
+    if (StringBeginsWith(name, NS_LITERAL_STRING("gl_"))) {
+        mContext->ErrorInvalidOperation("bindAttribLocation: Can't set the location of a"
+                                        " name that starts with 'gl_'.");
+        return;
+    }
+
+    NS_LossyConvertUTF16toASCII asciiName(name);
+
+    auto res = mNextLink_BoundAttribLocs.insert({asciiName, loc});
+
+    const bool wasInserted = res.second;
+    if (!wasInserted) {
+        auto itr = res.first;
+        itr->second = loc;
+    }
+}
+
+void
+WebGLProgram::DetachShader(const WebGLShader* shader)
+{
+    MOZ_ASSERT(shader);
+
+    WebGLRefPtr<WebGLShader>* shaderSlot;
+    switch (shader->mType) {
+    case LOCAL_GL_VERTEX_SHADER:
+        shaderSlot = &mVertShader;
+        break;
+    case LOCAL_GL_FRAGMENT_SHADER:
+        shaderSlot = &mFragShader;
+        break;
+    default:
+        mContext->ErrorInvalidOperation("attachShader: Bad type for shader.");
+        return;
+    }
+
+    if (*shaderSlot != shader) {
+        mContext->ErrorInvalidOperation("detachShader: `shader` is not attached.");
+        return;
+    }
+
+    *shaderSlot = nullptr;
+
+    mContext->MakeContextCurrent();
+    mContext->gl->fDetachShader(mGLName, shader->mGLName);
+}
+
+already_AddRefed<WebGLActiveInfo>
+WebGLProgram::GetActiveAttrib(GLuint index) const
+{
+    if (!mMostRecentLinkInfo) {
+        RefPtr<WebGLActiveInfo> ret = WebGLActiveInfo::CreateInvalid(mContext);
+        return ret.forget();
+    }
+
+    const auto& attribs = mMostRecentLinkInfo->attribs;
+
+    if (index >= attribs.size()) {
+        mContext->ErrorInvalidValue("`index` (%i) must be less than %s (%i).",
+                                    index, "ACTIVE_ATTRIBS", attribs.size());
+        return nullptr;
+    }
+
+    RefPtr<WebGLActiveInfo> ret = attribs[index].mActiveInfo;
+    return ret.forget();
+}
+
+already_AddRefed<WebGLActiveInfo>
+WebGLProgram::GetActiveUniform(GLuint index) const
+{
+    if (!mMostRecentLinkInfo) {
+        // According to the spec, this can return null.
+        RefPtr<WebGLActiveInfo> ret = WebGLActiveInfo::CreateInvalid(mContext);
+        return ret.forget();
+    }
+
+    const auto& uniforms = mMostRecentLinkInfo->uniforms;
+
+    if (index >= uniforms.size()) {
+        mContext->ErrorInvalidValue("`index` (%i) must be less than %s (%i).",
+                                    index, "ACTIVE_UNIFORMS", uniforms.size());
+        return nullptr;
+    }
+
+    RefPtr<WebGLActiveInfo> ret = uniforms[index]->mActiveInfo;
+    return ret.forget();
+}
+
+void
+WebGLProgram::GetAttachedShaders(nsTArray<RefPtr<WebGLShader>>* const out) const
+{
+    out->TruncateLength(0);
+
+    if (mVertShader)
+        out->AppendElement(mVertShader);
+
+    if (mFragShader)
+        out->AppendElement(mFragShader);
+}
+
+GLint
+WebGLProgram::GetAttribLocation(const nsAString& userName_wide) const
+{
+    if (!ValidateGLSLVariableName(userName_wide, mContext, "getAttribLocation"))
+        return -1;
+
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getAttribLocation: `program` must be linked.");
+        return -1;
+    }
+
+    const NS_LossyConvertUTF16toASCII userName(userName_wide);
+
+    const webgl::AttribInfo* info;
+    if (!LinkInfo()->FindAttrib(userName, &info))
+        return -1;
+
+    return GLint(info->mLoc);
+}
+
+static GLint
+GetFragDataByUserName(const WebGLProgram* prog,
+                      const nsCString& userName)
+{
+    nsCString mappedName;
+    if (!prog->LinkInfo()->MapFragDataName(userName, &mappedName))
+        return -1;
+
+    return prog->mContext->gl->fGetFragDataLocation(prog->mGLName, mappedName.BeginReading());
+}
+
+GLint
+WebGLProgram::GetFragDataLocation(const nsAString& userName_wide) const
+{
+    if (!ValidateGLSLVariableName(userName_wide, mContext, "getFragDataLocation"))
+        return -1;
+
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getFragDataLocation: `program` must be linked.");
+        return -1;
+    }
+
+
+    const auto& gl = mContext->gl;
+    gl->MakeCurrent();
+
+    const NS_LossyConvertUTF16toASCII userName(userName_wide);
+#ifdef XP_MACOSX
+    if (gl->WorkAroundDriverBugs()) {
+        // OSX doesn't return locs for indexed names, just the base names.
+        // Indicated by failure in: conformance2/programs/gl-get-frag-data-location.html
+        bool isArray;
+        size_t arrayIndex;
+        nsCString baseUserName;
+        if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
+            return -1;
+
+        if (arrayIndex >= mContext->mImplMaxDrawBuffers)
+            return -1;
+
+        const auto baseLoc = GetFragDataByUserName(this, baseUserName);
+        const auto loc = baseLoc + GLint(arrayIndex);
+        return loc;
+    }
+#endif
+    return GetFragDataByUserName(this, userName);
+}
+
+void
+WebGLProgram::GetProgramInfoLog(nsAString* const out) const
+{
+    CopyASCIItoUTF16(mLinkLog, *out);
+}
+
+static GLint
+GetProgramiv(gl::GLContext* gl, GLuint program, GLenum pname)
+{
+    GLint ret = 0;
+    gl->fGetProgramiv(program, pname, &ret);
+    return ret;
+}
+
+JS::Value
+WebGLProgram::GetProgramParameter(GLenum pname) const
+{
+    gl::GLContext* gl = mContext->gl;
+    gl->MakeCurrent();
+
+    if (mContext->IsWebGL2()) {
+        switch (pname) {
+        case LOCAL_GL_ACTIVE_UNIFORM_BLOCKS:
+            if (!IsLinked())
+                return JS::NumberValue(0);
+            return JS::NumberValue(LinkInfo()->uniformBlocks.size());
+
+        case LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS:
+            if (!IsLinked())
+                return JS::NumberValue(0);
+            return JS::NumberValue(LinkInfo()->transformFeedbackVaryings.size());
+
+        case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
+            if (!IsLinked())
+                return JS::NumberValue(LOCAL_GL_INTERLEAVED_ATTRIBS);
+            return JS::NumberValue(LinkInfo()->transformFeedbackBufferMode);
+       }
+    }
+
+    switch (pname) {
+    case LOCAL_GL_ATTACHED_SHADERS:
+        return JS::NumberValue( int(bool(mVertShader.get())) + int(bool(mFragShader)) );
+
+    case LOCAL_GL_ACTIVE_UNIFORMS:
+        if (!IsLinked())
+            return JS::NumberValue(0);
+        return JS::NumberValue(LinkInfo()->uniforms.size());
+
+    case LOCAL_GL_ACTIVE_ATTRIBUTES:
+        if (!IsLinked())
+            return JS::NumberValue(0);
+        return JS::NumberValue(LinkInfo()->attribs.size());
+
+    case LOCAL_GL_DELETE_STATUS:
+        return JS::BooleanValue(IsDeleteRequested());
+
+    case LOCAL_GL_LINK_STATUS:
+        return JS::BooleanValue(IsLinked());
+
+    case LOCAL_GL_VALIDATE_STATUS:
+#ifdef XP_MACOSX
+        // See comment in ValidateProgram.
+        if (gl->WorkAroundDriverBugs())
+            return JS::BooleanValue(true);
+#endif
+        // Todo: Implement this in our code.
+        return JS::BooleanValue(bool(GetProgramiv(gl, mGLName, pname)));
+
+    default:
+        mContext->ErrorInvalidEnumInfo("getProgramParameter: `pname`",
+                                       pname);
+        return JS::NullValue();
+    }
+}
+
+GLuint
+WebGLProgram::GetUniformBlockIndex(const nsAString& userName_wide) const
+{
+    if (!ValidateGLSLVariableName(userName_wide, mContext, "getUniformBlockIndex"))
+        return LOCAL_GL_INVALID_INDEX;
+
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getUniformBlockIndex: `program` must be linked.");
+        return LOCAL_GL_INVALID_INDEX;
+    }
+
+    const NS_LossyConvertUTF16toASCII userName(userName_wide);
+
+    const webgl::UniformBlockInfo* info = nullptr;
+    for (const auto& cur : LinkInfo()->uniformBlocks) {
+        if (cur->mUserName == userName) {
+            info = cur;
+            break;
+        }
+    }
+    if (!info)
+        return LOCAL_GL_INVALID_INDEX;
+
+    const auto& mappedName = info->mMappedName;
+
+    gl::GLContext* gl = mContext->GL();
+    gl->MakeCurrent();
+    return gl->fGetUniformBlockIndex(mGLName, mappedName.BeginReading());
+}
+
+void
+WebGLProgram::GetActiveUniformBlockName(GLuint uniformBlockIndex, nsAString& retval) const
+{
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getActiveUniformBlockName: `program` must be linked.");
+        return;
+    }
+
+    const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
+    GLuint uniformBlockCount = (GLuint) linkInfo->uniformBlocks.size();
+    if (uniformBlockIndex >= uniformBlockCount) {
+        mContext->ErrorInvalidValue("getActiveUniformBlockName: index %u invalid.", uniformBlockIndex);
+        return;
+    }
+
+    const auto& blockInfo = linkInfo->uniformBlocks[uniformBlockIndex];
+    retval.Assign(NS_ConvertASCIItoUTF16(blockInfo->mUserName));
+}
+
+JS::Value
+WebGLProgram::GetActiveUniformBlockParam(GLuint uniformBlockIndex, GLenum pname) const
+{
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getActiveUniformBlockParameter: `program` must be linked.");
+        return JS::NullValue();
+    }
+
+    const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
+    GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
+    if (uniformBlockIndex >= uniformBlockCount) {
+        mContext->ErrorInvalidValue("getActiveUniformBlockParameter: index %u invalid.", uniformBlockIndex);
+        return JS::NullValue();
+    }
+
+    gl::GLContext* gl = mContext->GL();
+    GLint param = 0;
+
+    switch (pname) {
+    case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+    case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+        gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, &param);
+        return JS::BooleanValue(bool(param));
+
+    case LOCAL_GL_UNIFORM_BLOCK_BINDING:
+    case LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE:
+    case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+        gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, &param);
+        return JS::NumberValue(param);
+
+    default:
+        MOZ_CRASH("bad `pname`.");
+    }
+}
+
+JS::Value
+WebGLProgram::GetActiveUniformBlockActiveUniforms(JSContext* cx, GLuint uniformBlockIndex,
+                                                  ErrorResult* const out_error) const
+{
+    const char funcName[] = "getActiveUniformBlockParameter";
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("%s: `program` must be linked.", funcName);
+        return JS::NullValue();
+    }
+
+    const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
+    GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
+    if (uniformBlockIndex >= uniformBlockCount) {
+        mContext->ErrorInvalidValue("%s: Index %u invalid.", funcName, uniformBlockIndex);
+        return JS::NullValue();
+    }
+
+    gl::GLContext* gl = mContext->GL();
+    GLint activeUniformCount = 0;
+    gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex,
+                                 LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS,
+                                 &activeUniformCount);
+    JS::RootedObject obj(cx, dom::Uint32Array::Create(cx, mContext, activeUniformCount,
+                                                      nullptr));
+    if (!obj) {
+        *out_error = NS_ERROR_OUT_OF_MEMORY;
+        return JS::NullValue();
+    }
+
+    dom::Uint32Array result;
+    DebugOnly<bool> inited = result.Init(obj);
+    MOZ_ASSERT(inited);
+    result.ComputeLengthAndData();
+    gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex,
+                                 LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
+                                 (GLint*)result.Data());
+
+    return JS::ObjectValue(*obj);
+}
+
+already_AddRefed<WebGLUniformLocation>
+WebGLProgram::GetUniformLocation(const nsAString& userName_wide) const
+{
+    if (!ValidateGLSLVariableName(userName_wide, mContext, "getUniformLocation"))
+        return nullptr;
+
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getUniformLocation: `program` must be linked.");
+        return nullptr;
+    }
+
+    const NS_LossyConvertUTF16toASCII userName(userName_wide);
+
+    // GLES 2.0.25, Section 2.10, p35
+    // If the the uniform location is an array, then the location of the first
+    // element of that array can be retrieved by either using the name of the
+    // uniform array, or the name of the uniform array appended with "[0]".
+    nsCString mappedName;
+    size_t arrayIndex;
+    webgl::UniformInfo* info;
+    if (!LinkInfo()->FindUniform(userName, &mappedName, &arrayIndex, &info))
+        return nullptr;
+
+    gl::GLContext* gl = mContext->GL();
+    gl->MakeCurrent();
+
+    GLint loc = gl->fGetUniformLocation(mGLName, mappedName.BeginReading());
+    if (loc == -1)
+        return nullptr;
+
+    RefPtr<WebGLUniformLocation> locObj = new WebGLUniformLocation(mContext, LinkInfo(),
+                                                                   info, loc, arrayIndex);
+    return locObj.forget();
+}
+
+void
+WebGLProgram::GetUniformIndices(const dom::Sequence<nsString>& uniformNames,
+                                dom::Nullable< nsTArray<GLuint> >& retval) const
+{
+    const char funcName[] = "getUniformIndices";
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("%s: `program` must be linked.", funcName);
+        return;
+    }
+
+    size_t count = uniformNames.Length();
+    nsTArray<GLuint>& arr = retval.SetValue();
+
+    gl::GLContext* gl = mContext->GL();
+    gl->MakeCurrent();
+
+    for (size_t i = 0; i < count; i++) {
+        const NS_LossyConvertUTF16toASCII userName(uniformNames[i]);
+
+        nsCString mappedName;
+        size_t arrayIndex;
+        webgl::UniformInfo* info;
+        if (!LinkInfo()->FindUniform(userName, &mappedName, &arrayIndex, &info)) {
+            arr.AppendElement(LOCAL_GL_INVALID_INDEX);
+            continue;
+        }
+
+        const GLchar* const mappedNameBegin = mappedName.get();
+
+        GLuint index = LOCAL_GL_INVALID_INDEX;
+        gl->fGetUniformIndices(mGLName, 1, &mappedNameBegin, &index);
+        arr.AppendElement(index);
+    }
+}
+
+void
+WebGLProgram::UniformBlockBinding(GLuint uniformBlockIndex,
+                                  GLuint uniformBlockBinding) const
+{
+    const char funcName[] = "getActiveUniformBlockName";
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("%s: `program` must be linked.", funcName);
+        return;
+    }
+
+    const auto& uniformBlocks = LinkInfo()->uniformBlocks;
+    if (uniformBlockIndex >= uniformBlocks.size()) {
+        mContext->ErrorInvalidValue("%s: Index %u invalid.", funcName, uniformBlockIndex);
+        return;
+    }
+    const auto& uniformBlock = uniformBlocks[uniformBlockIndex];
+
+    const auto& indexedBindings = mContext->mIndexedUniformBufferBindings;
+    if (uniformBlockBinding >= indexedBindings.size()) {
+        mContext->ErrorInvalidValue("%s: Binding %u invalid.", funcName,
+                                    uniformBlockBinding);
+        return;
+    }
+    const auto& indexedBinding = indexedBindings[uniformBlockBinding];
+
+    ////
+
+    gl::GLContext* gl = mContext->GL();
+    gl->MakeCurrent();
+    gl->fUniformBlockBinding(mGLName, uniformBlockIndex, uniformBlockBinding);
+
+    ////
+
+    uniformBlock->mBinding = &indexedBinding;
+}
+
+bool
+WebGLProgram::ValidateForLink()
+{
+    if (!mVertShader || !mVertShader->IsCompiled()) {
+        mLinkLog.AssignLiteral("Must have a compiled vertex shader attached.");
+        return false;
+    }
+
+    if (!mFragShader || !mFragShader->IsCompiled()) {
+        mLinkLog.AssignLiteral("Must have an compiled fragment shader attached.");
+        return false;
+    }
+
+    if (!mFragShader->CanLinkTo(mVertShader, &mLinkLog))
+        return false;
+
+    const auto& gl = mContext->gl;
+
+    if (gl->WorkAroundDriverBugs() &&
+        mContext->mIsMesa)
+    {
+        // Bug 777028: Mesa can't handle more than 16 samplers per program,
+        // counting each array entry.
+        size_t numSamplerUniforms_upperBound = mVertShader->CalcNumSamplerUniforms() +
+                                               mFragShader->CalcNumSamplerUniforms();
+        if (numSamplerUniforms_upperBound > 16) {
+            mLinkLog.AssignLiteral("Programs with more than 16 samplers are disallowed on"
+                                   " Mesa drivers to avoid crashing.");
+            return false;
+        }
+
+        // Bug 1203135: Mesa crashes internally if we exceed the reported maximum attribute count.
+        if (mVertShader->NumAttributes() > mContext->MaxVertexAttribs()) {
+            mLinkLog.AssignLiteral("Number of attributes exceeds Mesa's reported max"
+                                   " attribute count.");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void
+WebGLProgram::LinkProgram()
+{
+    const char funcName[] = "linkProgram";
+
+    if (mNumActiveTFOs) {
+        mContext->ErrorInvalidOperation("%s: Program is in-use by one or more active"
+                                        " transform feedback objects.",
+                                        funcName);
+        return;
+    }
+
+    mContext->MakeContextCurrent();
+    mContext->InvalidateBufferFetching(); // we do it early in this function
+    // as some of the validation changes program state
+
+    mLinkLog.Truncate();
+    mMostRecentLinkInfo = nullptr;
+
+    if (!ValidateForLink()) {
+        mContext->GenerateWarning("%s: %s", funcName, mLinkLog.BeginReading());
+        return;
+    }
+
+    // Bind the attrib locations.
+    // This can't be done trivially, because we have to deal with mapped attrib names.
+    for (const auto& pair : mNextLink_BoundAttribLocs) {
+        const auto& name = pair.first;
+        const auto& index = pair.second;
+
+        mVertShader->BindAttribLocation(mGLName, name, index);
+    }
+
+    // Storage for transform feedback varyings before link.
+    // (Work around for bug seen on nVidia drivers.)
+    std::vector<std::string> scopedMappedTFVaryings;
+
+    if (mContext->IsWebGL2()) {
+        mVertShader->MapTransformFeedbackVaryings(mNextLink_TransformFeedbackVaryings,
+                                                  &scopedMappedTFVaryings);
+
+        std::vector<const char*> driverVaryings;
+        driverVaryings.reserve(scopedMappedTFVaryings.size());
+        for (const auto& cur : scopedMappedTFVaryings) {
+            driverVaryings.push_back(cur.c_str());
+        }
+
+        mContext->gl->fTransformFeedbackVaryings(mGLName, driverVaryings.size(),
+                                                 driverVaryings.data(),
+                                                 mNextLink_TransformFeedbackBufferMode);
+    }
+
+    LinkAndUpdate();
+
+    if (mMostRecentLinkInfo) {
+        nsCString postLinkLog;
+        if (ValidateAfterTentativeLink(&postLinkLog))
+            return;
+
+        mMostRecentLinkInfo = nullptr;
+        mLinkLog = postLinkLog;
+    }
+
+    // Failed link.
+    if (mContext->ShouldGenerateWarnings()) {
+        // report shader/program infoLogs as warnings.
+        // note that shader compilation errors can be deferred to linkProgram,
+        // which is why we can't do anything in compileShader. In practice we could
+        // report in compileShader the translation errors generated by ANGLE,
+        // but it seems saner to keep a single way of obtaining shader infologs.
+        if (!mLinkLog.IsEmpty()) {
+            mContext->GenerateWarning("linkProgram: Failed to link, leaving the following"
+                                      " log:\n%s\n",
+                                      mLinkLog.BeginReading());
+        }
+    }
+}
+
+static uint8_t
+NumUsedLocationsByElemType(GLenum elemType)
+{
+    // GLES 3.0.4 p55
+
+    switch (elemType) {
+    case LOCAL_GL_FLOAT_MAT2:
+    case LOCAL_GL_FLOAT_MAT2x3:
+    case LOCAL_GL_FLOAT_MAT2x4:
+        return 2;
+
+    case LOCAL_GL_FLOAT_MAT3x2:
+    case LOCAL_GL_FLOAT_MAT3:
+    case LOCAL_GL_FLOAT_MAT3x4:
+        return 3;
+
+    case LOCAL_GL_FLOAT_MAT4x2:
+    case LOCAL_GL_FLOAT_MAT4x3:
+    case LOCAL_GL_FLOAT_MAT4:
+        return 4;
+
+    default:
+        return 1;
+    }
+}
+
+static uint8_t
+NumComponents(GLenum elemType)
+{
+    switch (elemType) {
+    case LOCAL_GL_FLOAT:
+    case LOCAL_GL_INT:
+    case LOCAL_GL_UNSIGNED_INT:
+    case LOCAL_GL_BOOL:
+        return 1;
+
+    case LOCAL_GL_FLOAT_VEC2:
+    case LOCAL_GL_INT_VEC2:
+    case LOCAL_GL_UNSIGNED_INT_VEC2:
+    case LOCAL_GL_BOOL_VEC2:
+        return 2;
+
+    case LOCAL_GL_FLOAT_VEC3:
+    case LOCAL_GL_INT_VEC3:
+    case LOCAL_GL_UNSIGNED_INT_VEC3:
+    case LOCAL_GL_BOOL_VEC3:
+        return 3;
+
+    case LOCAL_GL_FLOAT_VEC4:
+    case LOCAL_GL_INT_VEC4:
+    case LOCAL_GL_UNSIGNED_INT_VEC4:
+    case LOCAL_GL_BOOL_VEC4:
+    case LOCAL_GL_FLOAT_MAT2:
+        return 4;
+
+    case LOCAL_GL_FLOAT_MAT2x3:
+    case LOCAL_GL_FLOAT_MAT3x2:
+        return 6;
+
+    case LOCAL_GL_FLOAT_MAT2x4:
+    case LOCAL_GL_FLOAT_MAT4x2:
+        return 8;
+
+    case LOCAL_GL_FLOAT_MAT3:
+        return 9;
+
+    case LOCAL_GL_FLOAT_MAT3x4:
+    case LOCAL_GL_FLOAT_MAT4x3:
+        return 12;
+
+    case LOCAL_GL_FLOAT_MAT4:
+        return 16;
+
+    default:
+        MOZ_CRASH("`elemType`");
+    }
+}
+
+bool
+WebGLProgram::ValidateAfterTentativeLink(nsCString* const out_linkLog) const
+{
+    const auto& linkInfo = mMostRecentLinkInfo;
+    const auto& gl = mContext->gl;
+
+    // Check if the attrib name conflicting to uniform name
+    for (const auto& attrib : linkInfo->attribs) {
+        const auto& attribName = attrib.mActiveInfo->mBaseUserName;
+
+        for (const auto& uniform : linkInfo->uniforms) {
+            const auto& uniformName = uniform->mActiveInfo->mBaseUserName;
+            if (attribName == uniformName) {
+                *out_linkLog = nsPrintfCString("Attrib name conflicts with uniform name:"
+                                               " %s",
+                                               attribName.BeginReading());
+                return false;
+            }
+        }
+    }
+
+    std::map<uint32_t, const webgl::AttribInfo*> attribsByLoc;
+    for (const auto& attrib : linkInfo->attribs) {
+        if (attrib.mLoc == -1)
+            continue;
+
+        const auto& elemType = attrib.mActiveInfo->mElemType;
+        const auto numUsedLocs = NumUsedLocationsByElemType(elemType);
+        for (uint32_t i = 0; i < numUsedLocs; i++) {
+            const uint32_t usedLoc = attrib.mLoc + i;
+
+            const auto res = attribsByLoc.insert({usedLoc, &attrib});
+            const bool& didInsert = res.second;
+            if (!didInsert) {
+                const auto& aliasingName = attrib.mActiveInfo->mBaseUserName;
+                const auto& itrExisting = res.first;
+                const auto& existingInfo = itrExisting->second;
+                const auto& existingName = existingInfo->mActiveInfo->mBaseUserName;
+                *out_linkLog = nsPrintfCString("Attrib \"%s\" aliases locations used by"
+                                               " attrib \"%s\".",
+                                               aliasingName.BeginReading(),
+                                               existingName.BeginReading());
+                return false;
+            }
+        }
+    }
+
+    // Forbid:
+    // * Unrecognized varying name
+    // * Duplicate varying name
+    // * Too many components for specified buffer mode
+    if (mNextLink_TransformFeedbackVaryings.size()) {
+        GLuint maxComponentsPerIndex = 0;
+        switch (mNextLink_TransformFeedbackBufferMode) {
+        case LOCAL_GL_INTERLEAVED_ATTRIBS:
+            gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
+                             &maxComponentsPerIndex);
+            break;
+
+        case LOCAL_GL_SEPARATE_ATTRIBS:
+            gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
+                             &maxComponentsPerIndex);
+            break;
+
+        default:
+            MOZ_CRASH("`bufferMode`");
+        }
+
+        std::vector<size_t> componentsPerVert;
+        std::set<const WebGLActiveInfo*> alreadyUsed;
+        for (const auto& wideUserName : mNextLink_TransformFeedbackVaryings) {
+            if (!componentsPerVert.size() ||
+                mNextLink_TransformFeedbackBufferMode == LOCAL_GL_SEPARATE_ATTRIBS)
+            {
+                componentsPerVert.push_back(0);
+            }
+
+            ////
+
+            const WebGLActiveInfo* curInfo = nullptr;
+            for (const auto& info : linkInfo->transformFeedbackVaryings) {
+                const NS_ConvertASCIItoUTF16 info_wideUserName(info->mBaseUserName);
+                if (info_wideUserName == wideUserName) {
+                    curInfo = info.get();
+                    break;
+                }
+            }
+
+            if (!curInfo) {
+                const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
+                *out_linkLog = nsPrintfCString("Transform feedback varying \"%s\" not"
+                                               " found.",
+                                               asciiUserName.BeginReading());
+                return false;
+            }
+
+            const auto insertResPair = alreadyUsed.insert(curInfo);
+            const auto& didInsert = insertResPair.second;
+            if (!didInsert) {
+                const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
+                *out_linkLog = nsPrintfCString("Transform feedback varying \"%s\""
+                                               " specified twice.",
+                                               asciiUserName.BeginReading());
+                return false;
+            }
+
+            ////
+
+            size_t varyingComponents = NumComponents(curInfo->mElemType);
+            varyingComponents *= curInfo->mElemCount;
+
+            auto& totalComponentsForIndex = *(componentsPerVert.rbegin());
+            totalComponentsForIndex += varyingComponents;
+
+            if (totalComponentsForIndex > maxComponentsPerIndex) {
+                const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
+                *out_linkLog = nsPrintfCString("Transform feedback varying \"%s\""
+                                               " pushed `componentsForIndex` over the"
+                                               " limit of %u.",
+                                               asciiUserName.BeginReading(),
+                                               maxComponentsPerIndex);
+                return false;
+            }
+        }
+
+        linkInfo->componentsPerTFVert.swap(componentsPerVert);
+    }
+
+    return true;
+}
+
+bool
+WebGLProgram::UseProgram() const
+{
+    const char funcName[] = "useProgram";
+
+    if (!mMostRecentLinkInfo) {
+        mContext->ErrorInvalidOperation("%s: Program has not been successfully linked.",
+                                        funcName);
+        return false;
+    }
+
+    if (mContext->mBoundTransformFeedback &&
+        mContext->mBoundTransformFeedback->mIsActive &&
+        !mContext->mBoundTransformFeedback->mIsPaused)
+    {
+        mContext->ErrorInvalidOperation("%s: Transform feedback active and not paused.",
+                                        funcName);
+        return false;
+    }
+
+    mContext->MakeContextCurrent();
+
+    mContext->InvalidateBufferFetching();
+
+    mContext->gl->fUseProgram(mGLName);
+    return true;
+}
+
+void
+WebGLProgram::ValidateProgram() const
+{
+    mContext->MakeContextCurrent();
+    gl::GLContext* gl = mContext->gl;
+
+#ifdef XP_MACOSX
+    // See bug 593867 for NVIDIA and bug 657201 for ATI. The latter is confirmed
+    // with Mac OS 10.6.7.
+    if (gl->WorkAroundDriverBugs()) {
+        mContext->GenerateWarning("validateProgram: Implemented as a no-op on"
+                                  " Mac to work around crashes.");
+        return;
+    }
+#endif
+
+    gl->fValidateProgram(mGLName);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void
+WebGLProgram::LinkAndUpdate()
+{
+    mMostRecentLinkInfo = nullptr;
+
+    gl::GLContext* gl = mContext->gl;
+    gl->fLinkProgram(mGLName);
+
+    // Grab the program log.
+    GLuint logLenWithNull = 0;
+    gl->fGetProgramiv(mGLName, LOCAL_GL_INFO_LOG_LENGTH, (GLint*)&logLenWithNull);
+    if (logLenWithNull > 1) {
+        mLinkLog.SetLength(logLenWithNull - 1);
+        gl->fGetProgramInfoLog(mGLName, logLenWithNull, nullptr, mLinkLog.BeginWriting());
+    } else {
+        mLinkLog.SetLength(0);
+    }
+
+    GLint ok = 0;
+    gl->fGetProgramiv(mGLName, LOCAL_GL_LINK_STATUS, &ok);
+    if (!ok)
+        return;
+
+    mMostRecentLinkInfo = QueryProgramInfo(this, gl);
+    MOZ_RELEASE_ASSERT(mMostRecentLinkInfo, "GFX: most recent link info not set.");
+}
+
+bool
+WebGLProgram::FindAttribUserNameByMappedName(const nsACString& mappedName,
+                                             nsCString* const out_userName) const
+{
+    if (mVertShader->FindAttribUserNameByMappedName(mappedName, out_userName))
+        return true;
+
+    return false;
+}
+
+bool
+WebGLProgram::FindVaryingByMappedName(const nsACString& mappedName,
+                                              nsCString* const out_userName,
+                                              bool* const out_isArray) const
+{
+    if (mVertShader->FindVaryingByMappedName(mappedName, out_userName, out_isArray))
+        return true;
+
+    return false;
+}
+
+
+bool
+WebGLProgram::FindUniformByMappedName(const nsACString& mappedName,
+                                      nsCString* const out_userName,
+                                      bool* const out_isArray) const
+{
+    if (mVertShader->FindUniformByMappedName(mappedName, out_userName, out_isArray))
+        return true;
+
+    if (mFragShader->FindUniformByMappedName(mappedName, out_userName, out_isArray))
+        return true;
+
+    return false;
+}
+
+void
+WebGLProgram::TransformFeedbackVaryings(const dom::Sequence<nsString>& varyings,
+                                        GLenum bufferMode)
+{
+    const char funcName[] = "transformFeedbackVaryings";
+
+    const auto& gl = mContext->gl;
+    gl->MakeCurrent();
+
+    switch (bufferMode) {
+    case LOCAL_GL_INTERLEAVED_ATTRIBS:
+        break;
+
+    case LOCAL_GL_SEPARATE_ATTRIBS:
+        {
+            GLuint maxAttribs = 0;
+            gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
+                             &maxAttribs);
+            if (varyings.Length() > maxAttribs) {
+                mContext->ErrorInvalidValue("%s: Length of `varyings` exceeds %s.",
+                                            funcName,
+                                            "TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS");
+                return;
+            }
+        }
+        break;
+
+    default:
+        mContext->ErrorInvalidEnum("%s: Bad `bufferMode`: 0x%04x.", funcName, bufferMode);
+        return;
+    }
+
+    ////
+
+    mNextLink_TransformFeedbackVaryings.assign(varyings.Elements(),
+                                               varyings.Elements() + varyings.Length());
+    mNextLink_TransformFeedbackBufferMode = bufferMode;
+}
+
+already_AddRefed<WebGLActiveInfo>
+WebGLProgram::GetTransformFeedbackVarying(GLuint index) const
+{
+    // No docs in the WebGL 2 spec for this function. Taking the language for
+    // getActiveAttrib, which states that the function returns null on any error.
+    if (!IsLinked()) {
+        mContext->ErrorInvalidOperation("getTransformFeedbackVarying: `program` must be "
+                                        "linked.");
+        return nullptr;
+    }
+
+    if (index >= LinkInfo()->transformFeedbackVaryings.size()) {
+        mContext->ErrorInvalidValue("getTransformFeedbackVarying: `index` is greater or "
+                                    "equal to TRANSFORM_FEEDBACK_VARYINGS.");
+        return nullptr;
+    }
+
+    RefPtr<WebGLActiveInfo> ret = LinkInfo()->transformFeedbackVaryings[index];
+    return ret.forget();
+}
+
+bool
+WebGLProgram::UnmapUniformBlockName(const nsCString& mappedName,
+                                    nsCString* const out_userName) const
+{
+    nsCString baseMappedName;
+    bool isArray;
+    size_t arrayIndex;
+    if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
+        return false;
+
+    nsCString baseUserName;
+    if (!mVertShader->UnmapUniformBlockName(baseMappedName, &baseUserName) &&
+        !mFragShader->UnmapUniformBlockName(baseMappedName, &baseUserName))
+    {
+        return false;
+    }
+
+    AssembleName(baseUserName, isArray, arrayIndex, out_userName);
+    return true;
+}
+
+void
+WebGLProgram::EnumerateFragOutputs(std::map<nsCString, const nsCString> &out_FragOutputs) const
+{
+    MOZ_ASSERT(mFragShader);
+
+    mFragShader->EnumerateFragOutputs(out_FragOutputs);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+bool
+IsBaseName(const nsCString& name)
+{
+    if (!name.Length())
+        return true;
+
+    return name[name.Length() - 1] != ']'; // Doesn't end in ']'.
+}
+
+bool
+webgl::LinkedProgramInfo::FindAttrib(const nsCString& userName,
+                                     const webgl::AttribInfo** const out) const
+{
+    // VS inputs cannot be arrays or structures.
+    // `userName` is thus always `baseUserName`.
+    for (const auto& attrib : attribs) {
+        if (attrib.mActiveInfo->mBaseUserName == userName) {
+            *out = &attrib;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+webgl::LinkedProgramInfo::FindUniform(const nsCString& userName,
+                                      nsCString* const out_mappedName,
+                                      size_t* const out_arrayIndex,
+                                      webgl::UniformInfo** const out_info) const
+{
+    nsCString baseUserName;
+    bool isArray;
+    size_t arrayIndex;
+    if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
+        return false;
+
+    webgl::UniformInfo* info = nullptr;
+    for (const auto& uniform : uniforms) {
+        if (uniform->mActiveInfo->mBaseUserName == baseUserName) {
+            info = uniform;
+            break;
+        }
+    }
+    if (!info)
+        return false;
+
+    const auto& baseMappedName = info->mActiveInfo->mBaseMappedName;
+    AssembleName(baseMappedName, isArray, arrayIndex, out_mappedName);
+
+    *out_arrayIndex = arrayIndex;
+    *out_info = info;
+    return true;
+}
+
+bool
+webgl::LinkedProgramInfo::MapFragDataName(const nsCString& userName,
+                                          nsCString* const out_mappedName) const
+{
+    // FS outputs can be arrays, but not structures.
+
+    if (!fragDataMap.size()) {
+        // No mappings map from validation, so just forward it.
+        *out_mappedName = userName;
+        return true;
+    }
+
+    nsCString baseUserName;
+    bool isArray;
+    size_t arrayIndex;
+    if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
+        return false;
+
+    const auto itr = fragDataMap.find(baseUserName);
+    if (itr == fragDataMap.end())
+        return false;
+
+    const auto& baseMappedName = itr->second;
+    AssembleName(baseMappedName, isArray, arrayIndex, out_mappedName);
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+JSObject*
+WebGLProgram::WrapObject(JSContext* js, JS::Handle<JSObject*> givenProto)
+{
+    return dom::WebGLProgramBinding::Wrap(js, this, givenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLProgram, mVertShader, mFragShader)
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WebGLProgram, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WebGLProgram, Release)
+
+} // namespace mozilla