Remove ANGLE

This marks the end of EGL and OpenGL ES support on Windows.

The concepts of -opengl dynamic, -opengl desktop, QT_OPENGL=software,
etc. remain unchanged, with the exception of the disapperance of
everything ANGLE related.

CMake builds now work identically to qmake on Windows: they default to
'dynamic' OpenGL on Windows, unless -DINPUT_opengl=desktop is specified.

On Windows, Qt 6 is expected to default to the "dynamic" OpenGL model by
default, just like Qt 5.15. This can be changed by switching to "desktop"
OpenGL, which will link to opengl32 (publicly, so other libs and applications
will do so as well) and disallows using another OpenGL DLL.

The "dynamic" mode is essential still because the fallback to a software
rasterizer, such as the opengl32sw.dll we ship with the Qt packages,
has to to work exactly like in Qt 5, the removal of ANGLE does not
change this concept in any way (except of course that the middle option
of using ANGLE is now gone)

When it comes to the windows plugin's OpenGL blacklist feature, it works
like before and accepts the ANGLE/D3D related keywords. They will
then be ignored. Similarly, requesting QT_OPENGL=angle is ignored (but
will show a warning).

The D3D11 and DXGI configure time tests are removed: Qt 5.14 already
depends on D3D 11.1 and DXGI 1.3 headers being available unconditionally
on Win32 (in QRhi's D3D11 backend). No need to test for these.

[ChangeLog][Windows] ANGLE is no longer included with Qt. Dynamic OpenGL
builds work like before but ANGLE is no longer an option. OpenGL proper
or an alternative opengl32 implementation are the two remaining options
now. Attempting to set QT_OPENGL=angle or Qt::AA_UseOpenGLES will have
no effect on Windows.

Fixes: QTBUG-79103
Change-Id: Ia404e0d07f3fe191b27434d863c81180112ecb3b
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>

1 files changed, 0 insertions, 3066 deletions

diff --git a/src/3rdparty/angle/src/libANGLE/Program.cpp b/src/3rdparty/angle/src/libANGLE/Program.cpp
deleted file mode 100644
index 795d326041..0000000000
--- a/src/3rdparty/angle/src/libANGLE/Program.cpp
+++ /dev/null
@@ -1,3066 +0,0 @@
-//
-// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// Program.cpp: Implements the gl::Program class. Implements GL program objects
-// and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.
-
-#include "libANGLE/Program.h"
-
-#include <algorithm>
-
-#include "common/bitset_utils.h"
-#include "common/debug.h"
-#include "common/platform.h"
-#include "common/string_utils.h"
-#include "common/utilities.h"
-#include "compiler/translator/blocklayout.h"
-#include "libANGLE/Context.h"
-#include "libANGLE/MemoryProgramCache.h"
-#include "libANGLE/ProgramLinkedResources.h"
-#include "libANGLE/ResourceManager.h"
-#include "libANGLE/Uniform.h"
-#include "libANGLE/VaryingPacking.h"
-#include "libANGLE/features.h"
-#include "libANGLE/histogram_macros.h"
-#include "libANGLE/queryconversions.h"
-#include "libANGLE/renderer/GLImplFactory.h"
-#include "libANGLE/renderer/ProgramImpl.h"
-#include "platform/Platform.h"
-
-namespace gl
-{
-
-namespace
-{
-
-// This simplified cast function doesn't need to worry about advanced concepts like
-// depth range values, or casting to bool.
-template <typename DestT, typename SrcT>
-DestT UniformStateQueryCast(SrcT value);
-
-// From-Float-To-Integer Casts
-template <>
-GLint UniformStateQueryCast(GLfloat value)
-{
-    return clampCast<GLint>(roundf(value));
-}
-
-template <>
-GLuint UniformStateQueryCast(GLfloat value)
-{
-    return clampCast<GLuint>(roundf(value));
-}
-
-// From-Integer-to-Integer Casts
-template <>
-GLint UniformStateQueryCast(GLuint value)
-{
-    return clampCast<GLint>(value);
-}
-
-template <>
-GLuint UniformStateQueryCast(GLint value)
-{
-    return clampCast<GLuint>(value);
-}
-
-// From-Boolean-to-Anything Casts
-template <>
-GLfloat UniformStateQueryCast(GLboolean value)
-{
-    return (ConvertToBool(value) ? 1.0f : 0.0f);
-}
-
-template <>
-GLint UniformStateQueryCast(GLboolean value)
-{
-    return (ConvertToBool(value) ? 1 : 0);
-}
-
-template <>
-GLuint UniformStateQueryCast(GLboolean value)
-{
-    return (ConvertToBool(value) ? 1u : 0u);
-}
-
-// Default to static_cast
-template <typename DestT, typename SrcT>
-DestT UniformStateQueryCast(SrcT value)
-{
-    return static_cast<DestT>(value);
-}
-
-template <typename SrcT, typename DestT>
-void UniformStateQueryCastLoop(DestT *dataOut, const uint8_t *srcPointer, int components)
-{
-    for (int comp = 0; comp < components; ++comp)
-    {
-        // We only work with strides of 4 bytes for uniform components. (GLfloat/GLint)
-        // Don't use SrcT stride directly since GLboolean has a stride of 1 byte.
-        size_t offset               = comp * 4;
-        const SrcT *typedSrcPointer = reinterpret_cast<const SrcT *>(&srcPointer[offset]);
-        dataOut[comp]               = UniformStateQueryCast<DestT>(*typedSrcPointer);
-    }
-}
-
-template <typename VarT>
-GLuint GetResourceIndexFromName(const std::vector<VarT> &list, const std::string &name)
-{
-    std::string nameAsArrayName = name + "[0]";
-    for (size_t index = 0; index < list.size(); index++)
-    {
-        const VarT &resource = list[index];
-        if (resource.name == name || (resource.isArray() && resource.name == nameAsArrayName))
-        {
-            return static_cast<GLuint>(index);
-        }
-    }
-
-    return GL_INVALID_INDEX;
-}
-
-template <typename VarT>
-GLint GetVariableLocation(const std::vector<VarT> &list,
-                          const std::vector<VariableLocation> &locationList,
-                          const std::string &name)
-{
-    size_t nameLengthWithoutArrayIndex;
-    unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
-
-    for (size_t location = 0u; location < locationList.size(); ++location)
-    {
-        const VariableLocation &variableLocation = locationList[location];
-        if (!variableLocation.used())
-        {
-            continue;
-        }
-
-        const VarT &variable = list[variableLocation.index];
-
-        if (angle::BeginsWith(variable.name, name))
-        {
-            if (name.length() == variable.name.length())
-            {
-                ASSERT(name == variable.name);
-                // GLES 3.1 November 2016 page 87.
-                // The string exactly matches the name of the active variable.
-                return static_cast<GLint>(location);
-            }
-            if (name.length() + 3u == variable.name.length() && variable.isArray())
-            {
-                ASSERT(name + "[0]" == variable.name);
-                // The string identifies the base name of an active array, where the string would
-                // exactly match the name of the variable if the suffix "[0]" were appended to the
-                // string.
-                return static_cast<GLint>(location);
-            }
-        }
-        if (variable.isArray() && variableLocation.arrayIndex == arrayIndex &&
-            nameLengthWithoutArrayIndex + 3u == variable.name.length() &&
-            angle::BeginsWith(variable.name, name, nameLengthWithoutArrayIndex))
-        {
-            ASSERT(name.substr(0u, nameLengthWithoutArrayIndex) + "[0]" == variable.name);
-            // The string identifies an active element of the array, where the string ends with the
-            // concatenation of the "[" character, an integer (with no "+" sign, extra leading
-            // zeroes, or whitespace) identifying an array element, and the "]" character, the
-            // integer is less than the number of active elements of the array variable, and where
-            // the string would exactly match the enumerated name of the array if the decimal
-            // integer were replaced with zero.
-            return static_cast<GLint>(location);
-        }
-    }
-
-    return -1;
-}
-
-void CopyStringToBuffer(GLchar *buffer, const std::string &string, GLsizei bufSize, GLsizei *length)
-{
-    ASSERT(bufSize > 0);
-    strncpy(buffer, string.c_str(), bufSize);
-    buffer[bufSize - 1] = '\0';
-
-    if (length)
-    {
-        *length = static_cast<GLsizei>(strlen(buffer));
-    }
-}
-
-bool IncludeSameArrayElement(const std::set<std::string> &nameSet, const std::string &name)
-{
-    std::vector<unsigned int> subscripts;
-    std::string baseName = ParseResourceName(name, &subscripts);
-    for (auto nameInSet : nameSet)
-    {
-        std::vector<unsigned int> arrayIndices;
-        std::string arrayName = ParseResourceName(nameInSet, &arrayIndices);
-        if (baseName == arrayName &&
-            (subscripts.empty() || arrayIndices.empty() || subscripts == arrayIndices))
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool validateInterfaceBlocksCount(GLuint maxInterfaceBlocks,
-                                  const std::vector<sh::InterfaceBlock> &interfaceBlocks,
-                                  const std::string &errorMessage,
-                                  InfoLog &infoLog)
-{
-    GLuint blockCount = 0;
-    for (const sh::InterfaceBlock &block : interfaceBlocks)
-    {
-        if (block.staticUse || block.layout != sh::BLOCKLAYOUT_PACKED)
-        {
-            blockCount += (block.arraySize ? block.arraySize : 1);
-            if (blockCount > maxInterfaceBlocks)
-            {
-                infoLog << errorMessage << maxInterfaceBlocks << ")";
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-GLuint GetInterfaceBlockIndex(const std::vector<InterfaceBlock> &list, const std::string &name)
-{
-    std::vector<unsigned int> subscripts;
-    std::string baseName = ParseResourceName(name, &subscripts);
-
-    unsigned int numBlocks = static_cast<unsigned int>(list.size());
-    for (unsigned int blockIndex = 0; blockIndex < numBlocks; blockIndex++)
-    {
-        const auto &block = list[blockIndex];
-        if (block.name == baseName)
-        {
-            const bool arrayElementZero =
-                (subscripts.empty() && (!block.isArray || block.arrayElement == 0));
-            const bool arrayElementMatches =
-                (subscripts.size() == 1 && subscripts[0] == block.arrayElement);
-            if (arrayElementMatches || arrayElementZero)
-            {
-                return blockIndex;
-            }
-        }
-    }
-
-    return GL_INVALID_INDEX;
-}
-
-void GetInterfaceBlockName(const GLuint index,
-                           const std::vector<InterfaceBlock> &list,
-                           GLsizei bufSize,
-                           GLsizei *length,
-                           GLchar *name)
-{
-    ASSERT(index < list.size());
-
-    const auto &block = list[index];
-
-    if (bufSize > 0)
-    {
-        std::string blockName = block.name;
-
-        if (block.isArray)
-        {
-            blockName += ArrayString(block.arrayElement);
-        }
-        CopyStringToBuffer(name, blockName, bufSize, length);
-    }
-}
-
-void InitUniformBlockLinker(const gl::Context *context,
-                            const ProgramState &state,
-                            UniformBlockLinker *blockLinker)
-{
-    if (state.getAttachedVertexShader())
-    {
-        blockLinker->addShaderBlocks(GL_VERTEX_SHADER,
-                                     &state.getAttachedVertexShader()->getUniformBlocks(context));
-    }
-
-    if (state.getAttachedFragmentShader())
-    {
-        blockLinker->addShaderBlocks(GL_FRAGMENT_SHADER,
-                                     &state.getAttachedFragmentShader()->getUniformBlocks(context));
-    }
-
-    if (state.getAttachedComputeShader())
-    {
-        blockLinker->addShaderBlocks(GL_COMPUTE_SHADER,
-                                     &state.getAttachedComputeShader()->getUniformBlocks(context));
-    }
-}
-
-void InitShaderStorageBlockLinker(const gl::Context *context,
-                                  const ProgramState &state,
-                                  ShaderStorageBlockLinker *blockLinker)
-{
-    if (state.getAttachedVertexShader())
-    {
-        blockLinker->addShaderBlocks(
-            GL_VERTEX_SHADER, &state.getAttachedVertexShader()->getShaderStorageBlocks(context));
-    }
-
-    if (state.getAttachedFragmentShader())
-    {
-        blockLinker->addShaderBlocks(
-            GL_FRAGMENT_SHADER,
-            &state.getAttachedFragmentShader()->getShaderStorageBlocks(context));
-    }
-
-    if (state.getAttachedComputeShader())
-    {
-        blockLinker->addShaderBlocks(
-            GL_COMPUTE_SHADER, &state.getAttachedComputeShader()->getShaderStorageBlocks(context));
-    }
-}
-
-}  // anonymous namespace
-
-const char *const g_fakepath = "C:\\fakepath";
-
-InfoLog::InfoLog()
-{
-}
-
-InfoLog::~InfoLog()
-{
-}
-
-size_t InfoLog::getLength() const
-{
-    if (!mLazyStream)
-    {
-        return 0;
-    }
-
-    const std::string &logString = mLazyStream->str();
-    return logString.empty() ? 0 : logString.length() + 1;
-}
-
-void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
-{
-    size_t index = 0;
-
-    if (bufSize > 0)
-    {
-        const std::string logString(str());
-
-        if (!logString.empty())
-        {
-            index = std::min(static_cast<size_t>(bufSize) - 1, logString.length());
-            memcpy(infoLog, logString.c_str(), index);
-        }
-
-        infoLog[index] = '\0';
-    }
-
-    if (length)
-    {
-        *length = static_cast<GLsizei>(index);
-    }
-}
-
-// append a santized message to the program info log.
-// The D3D compiler includes a fake file path in some of the warning or error
-// messages, so lets remove all occurrences of this fake file path from the log.
-void InfoLog::appendSanitized(const char *message)
-{
-    ensureInitialized();
-
-    std::string msg(message);
-
-    size_t found;
-    do
-    {
-        found = msg.find(g_fakepath);
-        if (found != std::string::npos)
-        {
-            msg.erase(found, strlen(g_fakepath));
-        }
-    }
-    while (found != std::string::npos);
-
-    *mLazyStream << message << std::endl;
-}
-
-void InfoLog::reset()
-{
-}
-
-VariableLocation::VariableLocation() : arrayIndex(0), index(kUnused), ignored(false)
-{
-}
-
-VariableLocation::VariableLocation(unsigned int arrayIndex, unsigned int index)
-    : arrayIndex(arrayIndex), index(index), ignored(false)
-{
-    ASSERT(arrayIndex != GL_INVALID_INDEX);
-}
-
-SamplerBinding::SamplerBinding(GLenum textureTypeIn, size_t elementCount, bool unreferenced)
-    : textureType(textureTypeIn), boundTextureUnits(elementCount, 0), unreferenced(unreferenced)
-{
-}
-
-SamplerBinding::SamplerBinding(const SamplerBinding &other) = default;
-
-SamplerBinding::~SamplerBinding() = default;
-
-Program::Bindings::Bindings()
-{
-}
-
-Program::Bindings::~Bindings()
-{
-}
-
-void Program::Bindings::bindLocation(GLuint index, const std::string &name)
-{
-    mBindings[name] = index;
-}
-
-int Program::Bindings::getBinding(const std::string &name) const
-{
-    auto iter = mBindings.find(name);
-    return (iter != mBindings.end()) ? iter->second : -1;
-}
-
-Program::Bindings::const_iterator Program::Bindings::begin() const
-{
-    return mBindings.begin();
-}
-
-Program::Bindings::const_iterator Program::Bindings::end() const
-{
-    return mBindings.end();
-}
-
-ImageBinding::ImageBinding(size_t count) : boundImageUnits(count, 0)
-{
-}
-ImageBinding::ImageBinding(GLuint imageUnit, size_t count)
-{
-    for (size_t index = 0; index < count; ++index)
-    {
-        boundImageUnits.push_back(imageUnit + static_cast<GLuint>(index));
-    }
-}
-
-ImageBinding::ImageBinding(const ImageBinding &other) = default;
-
-ImageBinding::~ImageBinding() = default;
-
-ProgramState::ProgramState()
-    : mLabel(),
-      mAttachedFragmentShader(nullptr),
-      mAttachedVertexShader(nullptr),
-      mAttachedComputeShader(nullptr),
-      mAttachedGeometryShader(nullptr),
-      mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS),
-      mMaxActiveAttribLocation(0),
-      mSamplerUniformRange(0, 0),
-      mImageUniformRange(0, 0),
-      mAtomicCounterUniformRange(0, 0),
-      mBinaryRetrieveableHint(false),
-      mNumViews(-1)
-{
-    mComputeShaderLocalSize.fill(1);
-}
-
-ProgramState::~ProgramState()
-{
-    ASSERT(!mAttachedVertexShader && !mAttachedFragmentShader && !mAttachedComputeShader &&
-           !mAttachedGeometryShader);
-}
-
-const std::string &ProgramState::getLabel()
-{
-    return mLabel;
-}
-
-GLuint ProgramState::getUniformIndexFromName(const std::string &name) const
-{
-    return GetResourceIndexFromName(mUniforms, name);
-}
-
-GLuint ProgramState::getBufferVariableIndexFromName(const std::string &name) const
-{
-    return GetResourceIndexFromName(mBufferVariables, name);
-}
-
-GLuint ProgramState::getUniformIndexFromLocation(GLint location) const
-{
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mUniformLocations.size());
-    return mUniformLocations[location].index;
-}
-
-Optional<GLuint> ProgramState::getSamplerIndex(GLint location) const
-{
-    GLuint index = getUniformIndexFromLocation(location);
-    if (!isSamplerUniformIndex(index))
-    {
-        return Optional<GLuint>::Invalid();
-    }
-
-    return getSamplerIndexFromUniformIndex(index);
-}
-
-bool ProgramState::isSamplerUniformIndex(GLuint index) const
-{
-    return mSamplerUniformRange.contains(index);
-}
-
-GLuint ProgramState::getSamplerIndexFromUniformIndex(GLuint uniformIndex) const
-{
-    ASSERT(isSamplerUniformIndex(uniformIndex));
-    return uniformIndex - mSamplerUniformRange.low();
-}
-
-GLuint ProgramState::getAttributeLocation(const std::string &name) const
-{
-    for (const sh::Attribute &attribute : mAttributes)
-    {
-        if (attribute.name == name)
-        {
-            return attribute.location;
-        }
-    }
-
-    return static_cast<GLuint>(-1);
-}
-
-Program::Program(rx::GLImplFactory *factory, ShaderProgramManager *manager, GLuint handle)
-    : mProgram(factory->createProgram(mState)),
-      mValidated(false),
-      mLinked(false),
-      mDeleteStatus(false),
-      mRefCount(0),
-      mResourceManager(manager),
-      mHandle(handle)
-{
-    ASSERT(mProgram);
-
-    unlink();
-}
-
-Program::~Program()
-{
-    ASSERT(!mProgram);
-}
-
-void Program::onDestroy(const Context *context)
-{
-    if (mState.mAttachedVertexShader != nullptr)
-    {
-        mState.mAttachedVertexShader->release(context);
-        mState.mAttachedVertexShader = nullptr;
-    }
-
-    if (mState.mAttachedFragmentShader != nullptr)
-    {
-        mState.mAttachedFragmentShader->release(context);
-        mState.mAttachedFragmentShader = nullptr;
-    }
-
-    if (mState.mAttachedComputeShader != nullptr)
-    {
-        mState.mAttachedComputeShader->release(context);
-        mState.mAttachedComputeShader = nullptr;
-    }
-
-    if (mState.mAttachedGeometryShader != nullptr)
-    {
-        mState.mAttachedGeometryShader->release(context);
-        mState.mAttachedGeometryShader = nullptr;
-    }
-
-    mProgram->destroy(context);
-
-    ASSERT(!mState.mAttachedVertexShader && !mState.mAttachedFragmentShader &&
-           !mState.mAttachedComputeShader && !mState.mAttachedGeometryShader);
-    SafeDelete(mProgram);
-
-    delete this;
-}
-
-void Program::setLabel(const std::string &label)
-{
-    mState.mLabel = label;
-}
-
-const std::string &Program::getLabel() const
-{
-    return mState.mLabel;
-}
-
-void Program::attachShader(Shader *shader)
-{
-    switch (shader->getType())
-    {
-        case GL_VERTEX_SHADER:
-        {
-            ASSERT(!mState.mAttachedVertexShader);
-            mState.mAttachedVertexShader = shader;
-            mState.mAttachedVertexShader->addRef();
-            break;
-        }
-        case GL_FRAGMENT_SHADER:
-        {
-            ASSERT(!mState.mAttachedFragmentShader);
-            mState.mAttachedFragmentShader = shader;
-            mState.mAttachedFragmentShader->addRef();
-            break;
-        }
-        case GL_COMPUTE_SHADER:
-        {
-            ASSERT(!mState.mAttachedComputeShader);
-            mState.mAttachedComputeShader = shader;
-            mState.mAttachedComputeShader->addRef();
-            break;
-        }
-        case GL_GEOMETRY_SHADER_EXT:
-        {
-            ASSERT(!mState.mAttachedGeometryShader);
-            mState.mAttachedGeometryShader = shader;
-            mState.mAttachedGeometryShader->addRef();
-            break;
-        }
-        default:
-            UNREACHABLE();
-    }
-}
-
-void Program::detachShader(const Context *context, Shader *shader)
-{
-    switch (shader->getType())
-    {
-        case GL_VERTEX_SHADER:
-        {
-            ASSERT(mState.mAttachedVertexShader == shader);
-            shader->release(context);
-            mState.mAttachedVertexShader = nullptr;
-            break;
-        }
-        case GL_FRAGMENT_SHADER:
-        {
-            ASSERT(mState.mAttachedFragmentShader == shader);
-            shader->release(context);
-            mState.mAttachedFragmentShader = nullptr;
-            break;
-        }
-        case GL_COMPUTE_SHADER:
-        {
-            ASSERT(mState.mAttachedComputeShader == shader);
-            shader->release(context);
-            mState.mAttachedComputeShader = nullptr;
-            break;
-        }
-        case GL_GEOMETRY_SHADER_EXT:
-        {
-            ASSERT(mState.mAttachedGeometryShader == shader);
-            shader->release(context);
-            mState.mAttachedGeometryShader = nullptr;
-            break;
-        }
-        default:
-            UNREACHABLE();
-    }
-}
-
-int Program::getAttachedShadersCount() const
-{
-    return (mState.mAttachedVertexShader ? 1 : 0) + (mState.mAttachedFragmentShader ? 1 : 0) +
-           (mState.mAttachedComputeShader ? 1 : 0) + (mState.mAttachedGeometryShader ? 1 : 0);
-}
-
-void Program::bindAttributeLocation(GLuint index, const char *name)
-{
-    mAttributeBindings.bindLocation(index, name);
-}
-
-void Program::bindUniformLocation(GLuint index, const char *name)
-{
-    mUniformLocationBindings.bindLocation(index, name);
-}
-
-void Program::bindFragmentInputLocation(GLint index, const char *name)
-{
-    mFragmentInputBindings.bindLocation(index, name);
-}
-
-BindingInfo Program::getFragmentInputBindingInfo(const Context *context, GLint index) const
-{
-    BindingInfo ret;
-    ret.type  = GL_NONE;
-    ret.valid = false;
-
-    Shader *fragmentShader = mState.getAttachedFragmentShader();
-    ASSERT(fragmentShader);
-
-    // Find the actual fragment shader varying we're interested in
-    const std::vector<sh::Varying> &inputs = fragmentShader->getInputVaryings(context);
-
-    for (const auto &binding : mFragmentInputBindings)
-    {
-        if (binding.second != static_cast<GLuint>(index))
-            continue;
-
-        ret.valid = true;
-
-        size_t nameLengthWithoutArrayIndex;
-        unsigned int arrayIndex = ParseArrayIndex(binding.first, &nameLengthWithoutArrayIndex);
-
-        for (const auto &in : inputs)
-        {
-            if (in.name.length() == nameLengthWithoutArrayIndex &&
-                angle::BeginsWith(in.name, binding.first, nameLengthWithoutArrayIndex))
-            {
-                if (in.isArray())
-                {
-                    // The client wants to bind either "name" or "name[0]".
-                    // GL ES 3.1 spec refers to active array names with language such as:
-                    // "if the string identifies the base name of an active array, where the
-                    // string would exactly match the name of the variable if the suffix "[0]"
-                    // were appended to the string".
-                    if (arrayIndex == GL_INVALID_INDEX)
-                        arrayIndex = 0;
-
-                    ret.name = in.mappedName + "[" + ToString(arrayIndex) + "]";
-                }
-                else
-                {
-                    ret.name = in.mappedName;
-                }
-                ret.type = in.type;
-                return ret;
-            }
-        }
-    }
-
-    return ret;
-}
-
-void Program::pathFragmentInputGen(const Context *context,
-                                   GLint index,
-                                   GLenum genMode,
-                                   GLint components,
-                                   const GLfloat *coeffs)
-{
-    // If the location is -1 then the command is silently ignored
-    if (index == -1)
-        return;
-
-    const auto &binding = getFragmentInputBindingInfo(context, index);
-
-    // If the input doesn't exist then then the command is silently ignored
-    // This could happen through optimization for example, the shader translator
-    // decides that a variable is not actually being used and optimizes it away.
-    if (binding.name.empty())
-        return;
-
-    mProgram->setPathFragmentInputGen(binding.name, genMode, components, coeffs);
-}
-
-// The attached shaders are checked for linking errors by matching up their variables.
-// Uniform, input and output variables get collected.
-// The code gets compiled into binaries.
-Error Program::link(const gl::Context *context)
-{
-    const auto &data = context->getContextState();
-
-    auto *platform   = ANGLEPlatformCurrent();
-    double startTime = platform->currentTime(platform);
-
-    unlink();
-
-    ProgramHash programHash;
-    auto *cache = context->getMemoryProgramCache();
-    if (cache)
-    {
-        ANGLE_TRY_RESULT(cache->getProgram(context, this, &mState, &programHash), mLinked);
-        ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.ProgramCache.LoadBinarySuccess", mLinked);
-    }
-
-    if (mLinked)
-    {
-        double delta = platform->currentTime(platform) - startTime;
-        int us       = static_cast<int>(delta * 1000000.0);
-        ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheHitTimeUS", us);
-        return NoError();
-    }
-
-    // Cache load failed, fall through to normal linking.
-    unlink();
-    mInfoLog.reset();
-
-    const Caps &caps = data.getCaps();
-
-    Shader *vertexShader   = mState.mAttachedVertexShader;
-    Shader *fragmentShader = mState.mAttachedFragmentShader;
-    Shader *computeShader  = mState.mAttachedComputeShader;
-
-    bool isComputeShaderAttached   = (computeShader != nullptr);
-    bool nonComputeShadersAttached = (vertexShader != nullptr || fragmentShader != nullptr);
-    // Check whether we both have a compute and non-compute shaders attached.
-    // If there are of both types attached, then linking should fail.
-    // OpenGL ES 3.10, 7.3 Program Objects, under LinkProgram
-    if (isComputeShaderAttached == true && nonComputeShadersAttached == true)
-    {
-        mInfoLog << "Both a compute and non-compute shaders are attached to the same program.";
-        return NoError();
-    }
-
-    if (computeShader)
-    {
-        if (!computeShader->isCompiled(context))
-        {
-            mInfoLog << "Attached compute shader is not compiled.";
-            return NoError();
-        }
-        ASSERT(computeShader->getType() == GL_COMPUTE_SHADER);
-
-        mState.mComputeShaderLocalSize = computeShader->getWorkGroupSize(context);
-
-        // GLSL ES 3.10, 4.4.1.1 Compute Shader Inputs
-        // If the work group size is not specified, a link time error should occur.
-        if (!mState.mComputeShaderLocalSize.isDeclared())
-        {
-            mInfoLog << "Work group size is not specified.";
-            return NoError();
-        }
-
-        if (!linkUniforms(context, mInfoLog, mUniformLocationBindings))
-        {
-            return NoError();
-        }
-
-        if (!linkInterfaceBlocks(context, mInfoLog))
-        {
-            return NoError();
-        }
-
-        ProgramLinkedResources resources = {
-            {0, PackMode::ANGLE_RELAXED},
-            {&mState.mUniformBlocks, &mState.mUniforms},
-            {&mState.mShaderStorageBlocks, &mState.mBufferVariables}};
-
-        InitUniformBlockLinker(context, mState, &resources.uniformBlockLinker);
-        InitShaderStorageBlockLinker(context, mState, &resources.shaderStorageBlockLinker);
-
-        ANGLE_TRY_RESULT(mProgram->link(context, resources, mInfoLog), mLinked);
-        if (!mLinked)
-        {
-            return NoError();
-        }
-    }
-    else
-    {
-        if (!fragmentShader || !fragmentShader->isCompiled(context))
-        {
-            return NoError();
-        }
-        ASSERT(fragmentShader->getType() == GL_FRAGMENT_SHADER);
-
-        if (!vertexShader || !vertexShader->isCompiled(context))
-        {
-            return NoError();
-        }
-        ASSERT(vertexShader->getType() == GL_VERTEX_SHADER);
-
-        if (fragmentShader->getShaderVersion(context) != vertexShader->getShaderVersion(context))
-        {
-            mInfoLog << "Fragment shader version does not match vertex shader version.";
-            return NoError();
-        }
-
-        if (!linkAttributes(context, mInfoLog))
-        {
-            return NoError();
-        }
-
-        if (!linkVaryings(context, mInfoLog))
-        {
-            return NoError();
-        }
-
-        if (!linkUniforms(context, mInfoLog, mUniformLocationBindings))
-        {
-            return NoError();
-        }
-
-        if (!linkInterfaceBlocks(context, mInfoLog))
-        {
-            return NoError();
-        }
-
-        if (!linkValidateGlobalNames(context, mInfoLog))
-        {
-            return NoError();
-        }
-
-        const auto &mergedVaryings = getMergedVaryings(context);
-
-        mState.mNumViews = vertexShader->getNumViews(context);
-
-        linkOutputVariables(context);
-
-        // Map the varyings to the register file
-        // In WebGL, we use a slightly different handling for packing variables.
-        auto packMode = data.getExtensions().webglCompatibility ? PackMode::WEBGL_STRICT
-                                                                : PackMode::ANGLE_RELAXED;
-
-        ProgramLinkedResources resources = {
-            {data.getCaps().maxVaryingVectors, packMode},
-            {&mState.mUniformBlocks, &mState.mUniforms},
-            {&mState.mShaderStorageBlocks, &mState.mBufferVariables}};
-
-        InitUniformBlockLinker(context, mState, &resources.uniformBlockLinker);
-        InitShaderStorageBlockLinker(context, mState, &resources.shaderStorageBlockLinker);
-
-        if (!linkValidateTransformFeedback(context, mInfoLog, mergedVaryings, caps))
-        {
-            return NoError();
-        }
-
-        if (!resources.varyingPacking.collectAndPackUserVaryings(
-                mInfoLog, mergedVaryings, mState.getTransformFeedbackVaryingNames()))
-        {
-            return NoError();
-        }
-
-        ANGLE_TRY_RESULT(mProgram->link(context, resources, mInfoLog), mLinked);
-        if (!mLinked)
-        {
-            return NoError();
-        }
-
-        gatherTransformFeedbackVaryings(mergedVaryings);
-    }
-
-    gatherAtomicCounterBuffers();
-    initInterfaceBlockBindings();
-
-    setUniformValuesFromBindingQualifiers();
-
-    ASSERT(mLinked);
-    updateLinkedShaderStages();
-
-    // Mark implementation-specific unreferenced uniforms as ignored.
-    mProgram->markUnusedUniformLocations(&mState.mUniformLocations, &mState.mSamplerBindings);
-
-    // Save to the program cache.
-    if (cache && (mState.mLinkedTransformFeedbackVaryings.empty() ||
-                  !context->getWorkarounds().disableProgramCachingForTransformFeedback))
-    {
-        cache->putProgram(programHash, context, this);
-    }
-
-    double delta = platform->currentTime(platform) - startTime;
-    int us       = static_cast<int>(delta * 1000000.0);
-    ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheMissTimeUS", us);
-
-    return NoError();
-}
-
-void Program::updateLinkedShaderStages()
-{
-    if (mState.mAttachedVertexShader)
-    {
-        mState.mLinkedShaderStages.set(SHADER_VERTEX);
-    }
-
-    if (mState.mAttachedFragmentShader)
-    {
-        mState.mLinkedShaderStages.set(SHADER_FRAGMENT);
-    }
-
-    if (mState.mAttachedComputeShader)
-    {
-        mState.mLinkedShaderStages.set(SHADER_COMPUTE);
-    }
-}
-
-// Returns the program object to an unlinked state, before re-linking, or at destruction
-void Program::unlink()
-{
-    mState.mAttributes.clear();
-    mState.mActiveAttribLocationsMask.reset();
-    mState.mMaxActiveAttribLocation = 0;
-    mState.mLinkedTransformFeedbackVaryings.clear();
-    mState.mUniforms.clear();
-    mState.mUniformLocations.clear();
-    mState.mUniformBlocks.clear();
-    mState.mActiveUniformBlockBindings.reset();
-    mState.mAtomicCounterBuffers.clear();
-    mState.mOutputVariables.clear();
-    mState.mOutputLocations.clear();
-    mState.mOutputVariableTypes.clear();
-    mState.mActiveOutputVariables.reset();
-    mState.mComputeShaderLocalSize.fill(1);
-    mState.mSamplerBindings.clear();
-    mState.mImageBindings.clear();
-    mState.mNumViews = -1;
-    mState.mLinkedShaderStages.reset();
-
-    mValidated = false;
-
-    mLinked = false;
-}
-
-bool Program::isLinked() const
-{
-    return mLinked;
-}
-
-Error Program::loadBinary(const Context *context,
-                          GLenum binaryFormat,
-                          const void *binary,
-                          GLsizei length)
-{
-    unlink();
-
-#if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED
-    return NoError();
-#else
-    ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE);
-    if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
-    {
-        mInfoLog << "Invalid program binary format.";
-        return NoError();
-    }
-
-    const uint8_t *bytes = reinterpret_cast<const uint8_t *>(binary);
-    ANGLE_TRY_RESULT(
-        MemoryProgramCache::Deserialize(context, this, &mState, bytes, length, mInfoLog), mLinked);
-
-    // Currently we require the full shader text to compute the program hash.
-    // TODO(jmadill): Store the binary in the internal program cache.
-
-    return NoError();
-#endif  // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED
-}
-
-Error Program::saveBinary(const Context *context,
-                          GLenum *binaryFormat,
-                          void *binary,
-                          GLsizei bufSize,
-                          GLsizei *length) const
-{
-    if (binaryFormat)
-    {
-        *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
-    }
-
-    angle::MemoryBuffer memoryBuf;
-    MemoryProgramCache::Serialize(context, this, &memoryBuf);
-
-    GLsizei streamLength       = static_cast<GLsizei>(memoryBuf.size());
-    const uint8_t *streamState = memoryBuf.data();
-
-    if (streamLength > bufSize)
-    {
-        if (length)
-        {
-            *length = 0;
-        }
-
-        // TODO: This should be moved to the validation layer but computing the size of the binary before saving
-        // it causes the save to happen twice.  It may be possible to write the binary to a separate buffer, validate
-        // sizes and then copy it.
-        return InternalError();
-    }
-
-    if (binary)
-    {
-        char *ptr = reinterpret_cast<char*>(binary);
-
-        memcpy(ptr, streamState, streamLength);
-        ptr += streamLength;
-
-        ASSERT(ptr - streamLength == binary);
-    }
-
-    if (length)
-    {
-        *length = streamLength;
-    }
-
-    return NoError();
-}
-
-GLint Program::getBinaryLength(const Context *context) const
-{
-    GLint length;
-    Error error = saveBinary(context, nullptr, nullptr, std::numeric_limits<GLint>::max(), &length);
-    if (error.isError())
-    {
-        return 0;
-    }
-
-    return length;
-}
-
-void Program::setBinaryRetrievableHint(bool retrievable)
-{
-    // TODO(jmadill) : replace with dirty bits
-    mProgram->setBinaryRetrievableHint(retrievable);
-    mState.mBinaryRetrieveableHint = retrievable;
-}
-
-bool Program::getBinaryRetrievableHint() const
-{
-    return mState.mBinaryRetrieveableHint;
-}
-
-void Program::setSeparable(bool separable)
-{
-    // TODO(yunchao) : replace with dirty bits
-    if (mState.mSeparable != separable)
-    {
-        mProgram->setSeparable(separable);
-        mState.mSeparable = separable;
-    }
-}
-
-bool Program::isSeparable() const
-{
-    return mState.mSeparable;
-}
-
-void Program::release(const Context *context)
-{
-    mRefCount--;
-
-    if (mRefCount == 0 && mDeleteStatus)
-    {
-        mResourceManager->deleteProgram(context, mHandle);
-    }
-}
-
-void Program::addRef()
-{
-    mRefCount++;
-}
-
-unsigned int Program::getRefCount() const
-{
-    return mRefCount;
-}
-
-int Program::getInfoLogLength() const
-{
-    return static_cast<int>(mInfoLog.getLength());
-}
-
-void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
-{
-    return mInfoLog.getLog(bufSize, length, infoLog);
-}
-
-void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders) const
-{
-    int total = 0;
-
-    if (mState.mAttachedComputeShader)
-    {
-        if (total < maxCount)
-        {
-            shaders[total] = mState.mAttachedComputeShader->getHandle();
-            total++;
-        }
-    }
-
-    if (mState.mAttachedVertexShader)
-    {
-        if (total < maxCount)
-        {
-            shaders[total] = mState.mAttachedVertexShader->getHandle();
-            total++;
-        }
-    }
-
-    if (mState.mAttachedFragmentShader)
-    {
-        if (total < maxCount)
-        {
-            shaders[total] = mState.mAttachedFragmentShader->getHandle();
-            total++;
-        }
-    }
-
-    if (mState.mAttachedGeometryShader)
-    {
-        if (total < maxCount)
-        {
-            shaders[total] = mState.mAttachedGeometryShader->getHandle();
-            total++;
-        }
-    }
-
-    if (count)
-    {
-        *count = total;
-    }
-}
-
-GLuint Program::getAttributeLocation(const std::string &name) const
-{
-    return mState.getAttributeLocation(name);
-}
-
-bool Program::isAttribLocationActive(size_t attribLocation) const
-{
-    ASSERT(attribLocation < mState.mActiveAttribLocationsMask.size());
-    return mState.mActiveAttribLocationsMask[attribLocation];
-}
-
-void Program::getActiveAttribute(GLuint index,
-                                 GLsizei bufsize,
-                                 GLsizei *length,
-                                 GLint *size,
-                                 GLenum *type,
-                                 GLchar *name) const
-{
-    if (!mLinked)
-    {
-        if (bufsize > 0)
-        {
-            name[0] = '\0';
-        }
-
-        if (length)
-        {
-            *length = 0;
-        }
-
-        *type = GL_NONE;
-        *size = 1;
-        return;
-    }
-
-    ASSERT(index < mState.mAttributes.size());
-    const sh::Attribute &attrib = mState.mAttributes[index];
-
-    if (bufsize > 0)
-    {
-        CopyStringToBuffer(name, attrib.name, bufsize, length);
-    }
-
-    // Always a single 'type' instance
-    *size = 1;
-    *type = attrib.type;
-}
-
-GLint Program::getActiveAttributeCount() const
-{
-    if (!mLinked)
-    {
-        return 0;
-    }
-
-    return static_cast<GLint>(mState.mAttributes.size());
-}
-
-GLint Program::getActiveAttributeMaxLength() const
-{
-    if (!mLinked)
-    {
-        return 0;
-    }
-
-    size_t maxLength = 0;
-
-    for (const sh::Attribute &attrib : mState.mAttributes)
-    {
-        maxLength = std::max(attrib.name.length() + 1, maxLength);
-    }
-
-    return static_cast<GLint>(maxLength);
-}
-
-GLuint Program::getInputResourceIndex(const GLchar *name) const
-{
-    return GetResourceIndexFromName(mState.mAttributes, std::string(name));
-}
-
-GLuint Program::getOutputResourceIndex(const GLchar *name) const
-{
-    return GetResourceIndexFromName(mState.mOutputVariables, std::string(name));
-}
-
-size_t Program::getOutputResourceCount() const
-{
-    return (mLinked ? mState.mOutputVariables.size() : 0);
-}
-
-template <typename T>
-void Program::getResourceName(GLuint index,
-                              const std::vector<T> &resources,
-                              GLsizei bufSize,
-                              GLsizei *length,
-                              GLchar *name) const
-{
-    if (length)
-    {
-        *length = 0;
-    }
-
-    if (!mLinked)
-    {
-        if (bufSize > 0)
-        {
-            name[0] = '\0';
-        }
-        return;
-    }
-    ASSERT(index < resources.size());
-    const auto &resource = resources[index];
-
-    if (bufSize > 0)
-    {
-        CopyStringToBuffer(name, resource.name, bufSize, length);
-    }
-}
-
-void Program::getInputResourceName(GLuint index,
-                                   GLsizei bufSize,
-                                   GLsizei *length,
-                                   GLchar *name) const
-{
-    getResourceName(index, mState.mAttributes, bufSize, length, name);
-}
-
-void Program::getOutputResourceName(GLuint index,
-                                    GLsizei bufSize,
-                                    GLsizei *length,
-                                    GLchar *name) const
-{
-    getResourceName(index, mState.mOutputVariables, bufSize, length, name);
-}
-
-void Program::getUniformResourceName(GLuint index,
-                                     GLsizei bufSize,
-                                     GLsizei *length,
-                                     GLchar *name) const
-{
-    getResourceName(index, mState.mUniforms, bufSize, length, name);
-}
-
-void Program::getBufferVariableResourceName(GLuint index,
-                                            GLsizei bufSize,
-                                            GLsizei *length,
-                                            GLchar *name) const
-{
-    getResourceName(index, mState.mBufferVariables, bufSize, length, name);
-}
-
-const sh::Attribute &Program::getInputResource(GLuint index) const
-{
-    ASSERT(index < mState.mAttributes.size());
-    return mState.mAttributes[index];
-}
-
-const sh::OutputVariable &Program::getOutputResource(GLuint index) const
-{
-    ASSERT(index < mState.mOutputVariables.size());
-    return mState.mOutputVariables[index];
-}
-
-GLint Program::getFragDataLocation(const std::string &name) const
-{
-    return GetVariableLocation(mState.mOutputVariables, mState.mOutputLocations, name);
-}
-
-void Program::getActiveUniform(GLuint index,
-                               GLsizei bufsize,
-                               GLsizei *length,
-                               GLint *size,
-                               GLenum *type,
-                               GLchar *name) const
-{
-    if (mLinked)
-    {
-        // index must be smaller than getActiveUniformCount()
-        ASSERT(index < mState.mUniforms.size());
-        const LinkedUniform &uniform = mState.mUniforms[index];
-
-        if (bufsize > 0)
-        {
-            std::string string = uniform.name;
-            CopyStringToBuffer(name, string, bufsize, length);
-        }
-
-        *size = clampCast<GLint>(uniform.getBasicTypeElementCount());
-        *type = uniform.type;
-    }
-    else
-    {
-        if (bufsize > 0)
-        {
-            name[0] = '\0';
-        }
-
-        if (length)
-        {
-            *length = 0;
-        }
-
-        *size = 0;
-        *type = GL_NONE;
-    }
-}
-
-GLint Program::getActiveUniformCount() const
-{
-    if (mLinked)
-    {
-        return static_cast<GLint>(mState.mUniforms.size());
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-size_t Program::getActiveBufferVariableCount() const
-{
-    return mLinked ? mState.mBufferVariables.size() : 0;
-}
-
-GLint Program::getActiveUniformMaxLength() const
-{
-    size_t maxLength = 0;
-
-    if (mLinked)
-    {
-        for (const LinkedUniform &uniform : mState.mUniforms)
-        {
-            if (!uniform.name.empty())
-            {
-                size_t length = uniform.name.length() + 1u;
-                if (uniform.isArray())
-                {
-                    length += 3;  // Counting in "[0]".
-                }
-                maxLength = std::max(length, maxLength);
-            }
-        }
-    }
-
-    return static_cast<GLint>(maxLength);
-}
-
-bool Program::isValidUniformLocation(GLint location) const
-{
-    ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size()));
-    return (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() &&
-            mState.mUniformLocations[static_cast<size_t>(location)].used());
-}
-
-const LinkedUniform &Program::getUniformByLocation(GLint location) const
-{
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
-    return mState.mUniforms[mState.getUniformIndexFromLocation(location)];
-}
-
-const VariableLocation &Program::getUniformLocation(GLint location) const
-{
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
-    return mState.mUniformLocations[location];
-}
-
-const std::vector<VariableLocation> &Program::getUniformLocations() const
-{
-    return mState.mUniformLocations;
-}
-
-const LinkedUniform &Program::getUniformByIndex(GLuint index) const
-{
-    ASSERT(index < static_cast<size_t>(mState.mUniforms.size()));
-    return mState.mUniforms[index];
-}
-
-const BufferVariable &Program::getBufferVariableByIndex(GLuint index) const
-{
-    ASSERT(index < static_cast<size_t>(mState.mBufferVariables.size()));
-    return mState.mBufferVariables[index];
-}
-
-GLint Program::getUniformLocation(const std::string &name) const
-{
-    return GetVariableLocation(mState.mUniforms, mState.mUniformLocations, name);
-}
-
-GLuint Program::getUniformIndex(const std::string &name) const
-{
-    return mState.getUniformIndexFromName(name);
-}
-
-void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
-    mProgram->setUniform1fv(location, clampedCount, v);
-}
-
-void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2fv(location, clampedCount, v);
-}
-
-void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3fv(location, clampedCount, v);
-}
-
-void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4fv(location, clampedCount, v);
-}
-
-Program::SetUniformResult Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
-
-    mProgram->setUniform1iv(location, clampedCount, v);
-
-    if (mState.isSamplerUniformIndex(locationInfo.index))
-    {
-        updateSamplerUniform(locationInfo, clampedCount, v);
-        return SetUniformResult::SamplerChanged;
-    }
-
-    return SetUniformResult::NoSamplerChange;
-}
-
-void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2iv(location, clampedCount, v);
-}
-
-void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3iv(location, clampedCount, v);
-}
-
-void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4iv(location, clampedCount, v);
-}
-
-void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
-    mProgram->setUniform1uiv(location, clampedCount, v);
-}
-
-void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2uiv(location, clampedCount, v);
-}
-
-void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3uiv(location, clampedCount, v);
-}
-
-void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-    GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4uiv(location, clampedCount, v);
-}
-
-void Program::setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<2, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix2fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<3, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix3fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<4, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix4fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<2, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix2x3fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<2, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix2x4fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<3, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix3x2fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<3, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix3x4fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<4, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix4x2fv(location, clampedCount, transpose, v);
-}
-
-void Program::setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v)
-{
-    GLsizei clampedCount = clampMatrixUniformCount<4, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix4x3fv(location, clampedCount, transpose, v);
-}
-
-void Program::getUniformfv(const Context *context, GLint location, GLfloat *v) const
-{
-    const auto &uniformLocation = mState.getUniformLocations()[location];
-    const auto &uniform         = mState.getUniforms()[uniformLocation.index];
-
-    GLenum nativeType = gl::VariableComponentType(uniform.type);
-    if (nativeType == GL_FLOAT)
-    {
-        mProgram->getUniformfv(context, location, v);
-    }
-    else
-    {
-        getUniformInternal(context, v, location, nativeType,
-                           gl::VariableComponentCount(uniform.type));
-    }
-}
-
-void Program::getUniformiv(const Context *context, GLint location, GLint *v) const
-{
-    const auto &uniformLocation = mState.getUniformLocations()[location];
-    const auto &uniform         = mState.getUniforms()[uniformLocation.index];
-
-    GLenum nativeType = gl::VariableComponentType(uniform.type);
-    if (nativeType == GL_INT || nativeType == GL_BOOL)
-    {
-        mProgram->getUniformiv(context, location, v);
-    }
-    else
-    {
-        getUniformInternal(context, v, location, nativeType,
-                           gl::VariableComponentCount(uniform.type));
-    }
-}
-
-void Program::getUniformuiv(const Context *context, GLint location, GLuint *v) const
-{
-    const auto &uniformLocation = mState.getUniformLocations()[location];
-    const auto &uniform         = mState.getUniforms()[uniformLocation.index];
-
-    GLenum nativeType = gl::VariableComponentType(uniform.type);
-    if (nativeType == GL_UNSIGNED_INT)
-    {
-        mProgram->getUniformuiv(context, location, v);
-    }
-    else
-    {
-        getUniformInternal(context, v, location, nativeType,
-                           gl::VariableComponentCount(uniform.type));
-    }
-}
-
-void Program::flagForDeletion()
-{
-    mDeleteStatus = true;
-}
-
-bool Program::isFlaggedForDeletion() const
-{
-    return mDeleteStatus;
-}
-
-void Program::validate(const Caps &caps)
-{
-    mInfoLog.reset();
-
-    if (mLinked)
-    {
-        mValidated = ConvertToBool(mProgram->validate(caps, &mInfoLog));
-    }
-    else
-    {
-        mInfoLog << "Program has not been successfully linked.";
-    }
-}
-
-bool Program::validateSamplers(InfoLog *infoLog, const Caps &caps)
-{
-    // Skip cache if we're using an infolog, so we get the full error.
-    // Also skip the cache if the sample mapping has changed, or if we haven't ever validated.
-    if (infoLog == nullptr && mCachedValidateSamplersResult.valid())
-    {
-        return mCachedValidateSamplersResult.value();
-    }
-
-    if (mTextureUnitTypesCache.empty())
-    {
-        mTextureUnitTypesCache.resize(caps.maxCombinedTextureImageUnits, GL_NONE);
-    }
-    else
-    {
-        std::fill(mTextureUnitTypesCache.begin(), mTextureUnitTypesCache.end(), GL_NONE);
-    }
-
-    // if any two active samplers in a program are of different types, but refer to the same
-    // texture image unit, and this is the current program, then ValidateProgram will fail, and
-    // DrawArrays and DrawElements will issue the INVALID_OPERATION error.
-    for (const auto &samplerBinding : mState.mSamplerBindings)
-    {
-        if (samplerBinding.unreferenced)
-            continue;
-
-        GLenum textureType = samplerBinding.textureType;
-
-        for (GLuint textureUnit : samplerBinding.boundTextureUnits)
-        {
-            if (textureUnit >= caps.maxCombinedTextureImageUnits)
-            {
-                if (infoLog)
-                {
-                    (*infoLog) << "Sampler uniform (" << textureUnit
-                               << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ("
-                               << caps.maxCombinedTextureImageUnits << ")";
-                }
-
-                mCachedValidateSamplersResult = false;
-                return false;
-            }
-
-            if (mTextureUnitTypesCache[textureUnit] != GL_NONE)
-            {
-                if (textureType != mTextureUnitTypesCache[textureUnit])
-                {
-                    if (infoLog)
-                    {
-                        (*infoLog) << "Samplers of conflicting types refer to the same texture "
-                                      "image unit ("
-                                   << textureUnit << ").";
-                    }
-
-                    mCachedValidateSamplersResult = false;
-                    return false;
-                }
-            }
-            else
-            {
-                mTextureUnitTypesCache[textureUnit] = textureType;
-            }
-        }
-    }
-
-    mCachedValidateSamplersResult = true;
-    return true;
-}
-
-bool Program::isValidated() const
-{
-    return mValidated;
-}
-
-GLuint Program::getActiveUniformBlockCount() const
-{
-    return static_cast<GLuint>(mState.mUniformBlocks.size());
-}
-
-GLuint Program::getActiveAtomicCounterBufferCount() const
-{
-    return static_cast<GLuint>(mState.mAtomicCounterBuffers.size());
-}
-
-GLuint Program::getActiveShaderStorageBlockCount() const
-{
-    return static_cast<GLuint>(mState.mShaderStorageBlocks.size());
-}
-
-void Program::getActiveUniformBlockName(const GLuint blockIndex,
-                                        GLsizei bufSize,
-                                        GLsizei *length,
-                                        GLchar *blockName) const
-{
-    GetInterfaceBlockName(blockIndex, mState.mUniformBlocks, bufSize, length, blockName);
-}
-
-void Program::getActiveShaderStorageBlockName(const GLuint blockIndex,
-                                              GLsizei bufSize,
-                                              GLsizei *length,
-                                              GLchar *blockName) const
-{
-
-    GetInterfaceBlockName(blockIndex, mState.mShaderStorageBlocks, bufSize, length, blockName);
-}
-
-GLint Program::getActiveUniformBlockMaxLength() const
-{
-    int maxLength = 0;
-
-    if (mLinked)
-    {
-        unsigned int numUniformBlocks = static_cast<unsigned int>(mState.mUniformBlocks.size());
-        for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < numUniformBlocks; uniformBlockIndex++)
-        {
-            const InterfaceBlock &uniformBlock = mState.mUniformBlocks[uniformBlockIndex];
-            if (!uniformBlock.name.empty())
-            {
-                int length = static_cast<int>(uniformBlock.nameWithArrayIndex().length());
-                maxLength  = std::max(length + 1, maxLength);
-            }
-        }
-    }
-
-    return maxLength;
-}
-
-GLuint Program::getUniformBlockIndex(const std::string &name) const
-{
-    return GetInterfaceBlockIndex(mState.mUniformBlocks, name);
-}
-
-GLuint Program::getShaderStorageBlockIndex(const std::string &name) const
-{
-    return GetInterfaceBlockIndex(mState.mShaderStorageBlocks, name);
-}
-
-const InterfaceBlock &Program::getUniformBlockByIndex(GLuint index) const
-{
-    ASSERT(index < static_cast<GLuint>(mState.mUniformBlocks.size()));
-    return mState.mUniformBlocks[index];
-}
-
-const InterfaceBlock &Program::getShaderStorageBlockByIndex(GLuint index) const
-{
-    ASSERT(index < static_cast<GLuint>(mState.mShaderStorageBlocks.size()));
-    return mState.mShaderStorageBlocks[index];
-}
-
-void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    mState.mUniformBlocks[uniformBlockIndex].binding = uniformBlockBinding;
-    mState.mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlockBinding != 0);
-    mProgram->setUniformBlockBinding(uniformBlockIndex, uniformBlockBinding);
-}
-
-GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
-{
-    return mState.getUniformBlockBinding(uniformBlockIndex);
-}
-
-GLuint Program::getShaderStorageBlockBinding(GLuint shaderStorageBlockIndex) const
-{
-    return mState.getShaderStorageBlockBinding(shaderStorageBlockIndex);
-}
-
-void Program::setTransformFeedbackVaryings(GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
-{
-    mState.mTransformFeedbackVaryingNames.resize(count);
-    for (GLsizei i = 0; i < count; i++)
-    {
-        mState.mTransformFeedbackVaryingNames[i] = varyings[i];
-    }
-
-    mState.mTransformFeedbackBufferMode = bufferMode;
-}
-
-void Program::getTransformFeedbackVarying(GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) const
-{
-    if (mLinked)
-    {
-        ASSERT(index < mState.mLinkedTransformFeedbackVaryings.size());
-        const auto &var     = mState.mLinkedTransformFeedbackVaryings[index];
-        std::string varName = var.nameWithArrayIndex();
-        GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varName.length()));
-        if (length)
-        {
-            *length = lastNameIdx;
-        }
-        if (size)
-        {
-            *size = var.size();
-        }
-        if (type)
-        {
-            *type = var.type;
-        }
-        if (name)
-        {
-            memcpy(name, varName.c_str(), lastNameIdx);
-            name[lastNameIdx] = '\0';
-        }
-    }
-}
-
-GLsizei Program::getTransformFeedbackVaryingCount() const
-{
-    if (mLinked)
-    {
-        return static_cast<GLsizei>(mState.mLinkedTransformFeedbackVaryings.size());
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-GLsizei Program::getTransformFeedbackVaryingMaxLength() const
-{
-    if (mLinked)
-    {
-        GLsizei maxSize = 0;
-        for (const auto &var : mState.mLinkedTransformFeedbackVaryings)
-        {
-            maxSize =
-                std::max(maxSize, static_cast<GLsizei>(var.nameWithArrayIndex().length() + 1));
-        }
-
-        return maxSize;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-GLenum Program::getTransformFeedbackBufferMode() const
-{
-    return mState.mTransformFeedbackBufferMode;
-}
-
-bool Program::linkVaryings(const Context *context, InfoLog &infoLog) const
-{
-    Shader *vertexShader   = mState.mAttachedVertexShader;
-    Shader *fragmentShader = mState.mAttachedFragmentShader;
-
-    ASSERT(vertexShader->getShaderVersion(context) == fragmentShader->getShaderVersion(context));
-
-    const std::vector<sh::Varying> &vertexVaryings   = vertexShader->getOutputVaryings(context);
-    const std::vector<sh::Varying> &fragmentVaryings = fragmentShader->getInputVaryings(context);
-
-    std::map<GLuint, std::string> staticFragmentInputLocations;
-
-    for (const sh::Varying &output : fragmentVaryings)
-    {
-        bool matched = false;
-
-        // Built-in varyings obey special rules
-        if (output.isBuiltIn())
-        {
-            continue;
-        }
-
-        for (const sh::Varying &input : vertexVaryings)
-        {
-            if (output.name == input.name)
-            {
-                ASSERT(!input.isBuiltIn());
-                if (!linkValidateVaryings(infoLog, output.name, input, output,
-                                          vertexShader->getShaderVersion(context)))
-                {
-                    return false;
-                }
-
-                matched = true;
-                break;
-            }
-        }
-
-        // We permit unmatched, unreferenced varyings
-        if (!matched && output.staticUse)
-        {
-            infoLog << "Fragment varying " << output.name << " does not match any vertex varying";
-            return false;
-        }
-
-        // Check for aliased path rendering input bindings (if any).
-        // If more than one binding refer statically to the same
-        // location the link must fail.
-
-        if (!output.staticUse)
-            continue;
-
-        const auto inputBinding = mFragmentInputBindings.getBinding(output.name);
-        if (inputBinding == -1)
-            continue;
-
-        const auto it = staticFragmentInputLocations.find(inputBinding);
-        if (it == std::end(staticFragmentInputLocations))
-        {
-            staticFragmentInputLocations.insert(std::make_pair(inputBinding, output.name));
-        }
-        else
-        {
-            infoLog << "Binding for fragment input " << output.name << " conflicts with "
-                    << it->second;
-            return false;
-        }
-    }
-
-    if (!linkValidateBuiltInVaryings(context, infoLog))
-    {
-        return false;
-    }
-
-    // TODO(jmadill): verify no unmatched vertex varyings?
-
-    return true;
-}
-
-bool Program::linkUniforms(const Context *context,
-                           InfoLog &infoLog,
-                           const Bindings &uniformLocationBindings)
-{
-    UniformLinker linker(mState);
-    if (!linker.link(context, infoLog, uniformLocationBindings))
-    {
-        return false;
-    }
-
-    linker.getResults(&mState.mUniforms, &mState.mUniformLocations);
-
-    linkSamplerAndImageBindings();
-
-    if (!linkAtomicCounterBuffers())
-    {
-        return false;
-    }
-
-    return true;
-}
-
-void Program::linkSamplerAndImageBindings()
-{
-    unsigned int high = static_cast<unsigned int>(mState.mUniforms.size());
-    unsigned int low  = high;
-
-    for (auto counterIter = mState.mUniforms.rbegin();
-         counterIter != mState.mUniforms.rend() && counterIter->isAtomicCounter(); ++counterIter)
-    {
-        --low;
-    }
-
-    mState.mAtomicCounterUniformRange = RangeUI(low, high);
-
-    high = low;
-
-    for (auto imageIter = mState.mUniforms.rbegin();
-         imageIter != mState.mUniforms.rend() && imageIter->isImage(); ++imageIter)
-    {
-        --low;
-    }
-
-    mState.mImageUniformRange = RangeUI(low, high);
-
-    // If uniform is a image type, insert it into the mImageBindings array.
-    for (unsigned int imageIndex : mState.mImageUniformRange)
-    {
-        // ES3.1 (section 7.6.1) and GLSL ES3.1 (section 4.4.5), Uniform*i{v} commands
-        // cannot load values into a uniform defined as an image. if declare without a
-        // binding qualifier, any uniform image variable (include all elements of
-        // unbound image array) shoud be bound to unit zero.
-        auto &imageUniform = mState.mUniforms[imageIndex];
-        if (imageUniform.binding == -1)
-        {
-            mState.mImageBindings.emplace_back(
-                ImageBinding(imageUniform.getBasicTypeElementCount()));
-        }
-        else
-        {
-            mState.mImageBindings.emplace_back(
-                ImageBinding(imageUniform.binding, imageUniform.getBasicTypeElementCount()));
-        }
-    }
-
-    high = low;
-
-    for (auto samplerIter = mState.mUniforms.rbegin() + mState.mImageUniformRange.length();
-         samplerIter != mState.mUniforms.rend() && samplerIter->isSampler(); ++samplerIter)
-    {
-        --low;
-    }
-
-    mState.mSamplerUniformRange = RangeUI(low, high);
-
-    // If uniform is a sampler type, insert it into the mSamplerBindings array.
-    for (unsigned int samplerIndex : mState.mSamplerUniformRange)
-    {
-        const auto &samplerUniform = mState.mUniforms[samplerIndex];
-        GLenum textureType         = SamplerTypeToTextureType(samplerUniform.type);
-        mState.mSamplerBindings.emplace_back(
-            SamplerBinding(textureType, samplerUniform.getBasicTypeElementCount(), false));
-    }
-}
-
-bool Program::linkAtomicCounterBuffers()
-{
-    for (unsigned int index : mState.mAtomicCounterUniformRange)
-    {
-        auto &uniform = mState.mUniforms[index];
-        bool found    = false;
-        for (unsigned int bufferIndex = 0; bufferIndex < mState.mAtomicCounterBuffers.size();
-             ++bufferIndex)
-        {
-            auto &buffer = mState.mAtomicCounterBuffers[bufferIndex];
-            if (buffer.binding == uniform.binding)
-            {
-                buffer.memberIndexes.push_back(index);
-                uniform.bufferIndex = bufferIndex;
-                found               = true;
-                buffer.unionReferencesWith(uniform);
-                break;
-            }
-        }
-        if (!found)
-        {
-            AtomicCounterBuffer atomicCounterBuffer;
-            atomicCounterBuffer.binding = uniform.binding;
-            atomicCounterBuffer.memberIndexes.push_back(index);
-            atomicCounterBuffer.unionReferencesWith(uniform);
-            mState.mAtomicCounterBuffers.push_back(atomicCounterBuffer);
-            uniform.bufferIndex = static_cast<int>(mState.mAtomicCounterBuffers.size() - 1);
-        }
-    }
-    // TODO(jie.a.chen@intel.com): Count each atomic counter buffer to validate against
-    // gl_Max[Vertex|Fragment|Compute|Combined]AtomicCounterBuffers.
-
-    return true;
-}
-
-bool Program::linkValidateInterfaceBlockFields(InfoLog &infoLog,
-                                               const std::string &uniformName,
-                                               const sh::InterfaceBlockField &vertexUniform,
-                                               const sh::InterfaceBlockField &fragmentUniform,
-                                               bool webglCompatibility)
-{
-    // If webgl, validate precision of UBO fields, otherwise don't.  See Khronos bug 10287.
-    if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform,
-                                   webglCompatibility))
-    {
-        return false;
-    }
-
-    if (vertexUniform.isRowMajorLayout != fragmentUniform.isRowMajorLayout)
-    {
-        infoLog << "Matrix packings for " << uniformName << " differ between vertex and fragment shaders";
-        return false;
-    }
-
-    return true;
-}
-
-// Assigns locations to all attributes from the bindings and program locations.
-bool Program::linkAttributes(const Context *context, InfoLog &infoLog)
-{
-    const ContextState &data = context->getContextState();
-    auto *vertexShader       = mState.getAttachedVertexShader();
-
-    unsigned int usedLocations = 0;
-    mState.mAttributes         = vertexShader->getActiveAttributes(context);
-    GLuint maxAttribs          = data.getCaps().maxVertexAttributes;
-
-    // TODO(jmadill): handle aliasing robustly
-    if (mState.mAttributes.size() > maxAttribs)
-    {
-        infoLog << "Too many vertex attributes.";
-        return false;
-    }
-
-    std::vector<sh::Attribute *> usedAttribMap(maxAttribs, nullptr);
-
-    // Link attributes that have a binding location
-    for (sh::Attribute &attribute : mState.mAttributes)
-    {
-        // GLSL ES 3.10 January 2016 section 4.3.4: Vertex shader inputs can't be arrays or
-        // structures, so we don't need to worry about adjusting their names or generating entries
-        // for each member/element (unlike uniforms for example).
-        ASSERT(!attribute.isArray() && !attribute.isStruct());
-
-        int bindingLocation = mAttributeBindings.getBinding(attribute.name);
-        if (attribute.location == -1 && bindingLocation != -1)
-        {
-            attribute.location = bindingLocation;
-        }
-
-        if (attribute.location != -1)
-        {
-            // Location is set by glBindAttribLocation or by location layout qualifier
-            const int regs = VariableRegisterCount(attribute.type);
-
-            if (static_cast<GLuint>(regs + attribute.location) > maxAttribs)
-            {
-                infoLog << "Active attribute (" << attribute.name << ") at location "
-                        << attribute.location << " is too big to fit";
-
-                return false;
-            }
-
-            for (int reg = 0; reg < regs; reg++)
-            {
-                const int regLocation               = attribute.location + reg;
-                sh::ShaderVariable *linkedAttribute = usedAttribMap[regLocation];
-
-                // In GLSL 3.00, attribute aliasing produces a link error
-                // In GLSL 1.00, attribute aliasing is allowed, but ANGLE currently has a bug
-                if (linkedAttribute)
-                {
-                    // TODO(jmadill): fix aliasing on ES2
-                    // if (mProgram->getShaderVersion() >= 300)
-                    {
-                        infoLog << "Attribute '" << attribute.name << "' aliases attribute '"
-                                << linkedAttribute->name << "' at location " << regLocation;
-                        return false;
-                    }
-                }
-                else
-                {
-                    usedAttribMap[regLocation] = &attribute;
-                }
-
-                usedLocations |= 1 << regLocation;
-            }
-        }
-    }
-
-    // Link attributes that don't have a binding location
-    for (sh::Attribute &attribute : mState.mAttributes)
-    {
-        // Not set by glBindAttribLocation or by location layout qualifier
-        if (attribute.location == -1)
-        {
-            int regs           = VariableRegisterCount(attribute.type);
-            int availableIndex = AllocateFirstFreeBits(&usedLocations, regs, maxAttribs);
-
-            if (availableIndex == -1 || static_cast<GLuint>(availableIndex + regs) > maxAttribs)
-            {
-                infoLog << "Too many active attributes (" << attribute.name << ")";
-                return false;
-            }
-
-            attribute.location = availableIndex;
-        }
-    }
-
-    for (const sh::Attribute &attribute : mState.mAttributes)
-    {
-        ASSERT(attribute.location != -1);
-        unsigned int regs = static_cast<unsigned int>(VariableRegisterCount(attribute.type));
-
-        for (unsigned int r = 0; r < regs; r++)
-        {
-            unsigned int location = static_cast<unsigned int>(attribute.location) + r;
-            mState.mActiveAttribLocationsMask.set(location);
-            mState.mMaxActiveAttribLocation =
-                std::max(mState.mMaxActiveAttribLocation, location + 1);
-        }
-    }
-
-    return true;
-}
-
-bool Program::validateVertexAndFragmentInterfaceBlocks(
-    const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks,
-    const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks,
-    InfoLog &infoLog,
-    bool webglCompatibility) const
-{
-    // Check that interface blocks defined in the vertex and fragment shaders are identical
-    typedef std::map<std::string, const sh::InterfaceBlock *> InterfaceBlockMap;
-    InterfaceBlockMap linkedInterfaceBlocks;
-
-    for (const sh::InterfaceBlock &vertexInterfaceBlock : vertexInterfaceBlocks)
-    {
-        linkedInterfaceBlocks[vertexInterfaceBlock.name] = &vertexInterfaceBlock;
-    }
-
-    for (const sh::InterfaceBlock &fragmentInterfaceBlock : fragmentInterfaceBlocks)
-    {
-        auto entry = linkedInterfaceBlocks.find(fragmentInterfaceBlock.name);
-        if (entry != linkedInterfaceBlocks.end())
-        {
-            const sh::InterfaceBlock &vertexInterfaceBlock = *entry->second;
-            if (!areMatchingInterfaceBlocks(infoLog, vertexInterfaceBlock, fragmentInterfaceBlock,
-                                            webglCompatibility))
-            {
-                return false;
-            }
-        }
-        // TODO(jiajia.qin@intel.com): Add
-        // MAX_COMBINED_UNIFORM_BLOCKS/MAX_COMBINED_SHADER_STORAGE_BLOCKS validation.
-    }
-    return true;
-}
-
-bool Program::linkInterfaceBlocks(const Context *context, InfoLog &infoLog)
-{
-    const auto &caps = context->getCaps();
-
-    if (mState.mAttachedComputeShader)
-    {
-        Shader &computeShader              = *mState.mAttachedComputeShader;
-        const auto &computeUniformBlocks   = computeShader.getUniformBlocks(context);
-
-        if (!validateInterfaceBlocksCount(
-                caps.maxComputeUniformBlocks, computeUniformBlocks,
-                "Compute shader uniform block count exceeds GL_MAX_COMPUTE_UNIFORM_BLOCKS (",
-                infoLog))
-        {
-            return false;
-        }
-
-        const auto &computeShaderStorageBlocks = computeShader.getShaderStorageBlocks(context);
-        if (!validateInterfaceBlocksCount(caps.maxComputeShaderStorageBlocks,
-                                          computeShaderStorageBlocks,
-                                          "Compute shader shader storage block count exceeds "
-                                          "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS (",
-                                          infoLog))
-        {
-            return false;
-        }
-        return true;
-    }
-
-    Shader &vertexShader   = *mState.mAttachedVertexShader;
-    Shader &fragmentShader = *mState.mAttachedFragmentShader;
-
-    const auto &vertexUniformBlocks   = vertexShader.getUniformBlocks(context);
-    const auto &fragmentUniformBlocks = fragmentShader.getUniformBlocks(context);
-
-    if (!validateInterfaceBlocksCount(
-            caps.maxVertexUniformBlocks, vertexUniformBlocks,
-            "Vertex shader uniform block count exceeds GL_MAX_VERTEX_UNIFORM_BLOCKS (", infoLog))
-    {
-        return false;
-    }
-    if (!validateInterfaceBlocksCount(
-            caps.maxFragmentUniformBlocks, fragmentUniformBlocks,
-            "Fragment shader uniform block count exceeds GL_MAX_FRAGMENT_UNIFORM_BLOCKS (",
-            infoLog))
-    {
-
-        return false;
-    }
-
-    bool webglCompatibility = context->getExtensions().webglCompatibility;
-    if (!validateVertexAndFragmentInterfaceBlocks(vertexUniformBlocks, fragmentUniformBlocks,
-                                                  infoLog, webglCompatibility))
-    {
-        return false;
-    }
-
-    if (context->getClientVersion() >= Version(3, 1))
-    {
-        const auto &vertexShaderStorageBlocks   = vertexShader.getShaderStorageBlocks(context);
-        const auto &fragmentShaderStorageBlocks = fragmentShader.getShaderStorageBlocks(context);
-
-        if (!validateInterfaceBlocksCount(caps.maxVertexShaderStorageBlocks,
-                                          vertexShaderStorageBlocks,
-                                          "Vertex shader shader storage block count exceeds "
-                                          "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS (",
-                                          infoLog))
-        {
-            return false;
-        }
-        if (!validateInterfaceBlocksCount(caps.maxFragmentShaderStorageBlocks,
-                                          fragmentShaderStorageBlocks,
-                                          "Fragment shader shader storage block count exceeds "
-                                          "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS (",
-                                          infoLog))
-        {
-
-            return false;
-        }
-
-        if (!validateVertexAndFragmentInterfaceBlocks(vertexShaderStorageBlocks,
-                                                      fragmentShaderStorageBlocks, infoLog,
-                                                      webglCompatibility))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool Program::areMatchingInterfaceBlocks(InfoLog &infoLog,
-                                         const sh::InterfaceBlock &vertexInterfaceBlock,
-                                         const sh::InterfaceBlock &fragmentInterfaceBlock,
-                                         bool webglCompatibility) const
-{
-    const char* blockName = vertexInterfaceBlock.name.c_str();
-    // validate blocks for the same member types
-    if (vertexInterfaceBlock.fields.size() != fragmentInterfaceBlock.fields.size())
-    {
-        infoLog << "Types for interface block '" << blockName
-                << "' differ between vertex and fragment shaders";
-        return false;
-    }
-    if (vertexInterfaceBlock.arraySize != fragmentInterfaceBlock.arraySize)
-    {
-        infoLog << "Array sizes differ for interface block '" << blockName
-                << "' between vertex and fragment shaders";
-        return false;
-    }
-    if (vertexInterfaceBlock.layout != fragmentInterfaceBlock.layout ||
-        vertexInterfaceBlock.isRowMajorLayout != fragmentInterfaceBlock.isRowMajorLayout ||
-        vertexInterfaceBlock.binding != fragmentInterfaceBlock.binding)
-    {
-        infoLog << "Layout qualifiers differ for interface block '" << blockName
-                << "' between vertex and fragment shaders";
-        return false;
-    }
-    const unsigned int numBlockMembers =
-        static_cast<unsigned int>(vertexInterfaceBlock.fields.size());
-    for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++)
-    {
-        const sh::InterfaceBlockField &vertexMember = vertexInterfaceBlock.fields[blockMemberIndex];
-        const sh::InterfaceBlockField &fragmentMember = fragmentInterfaceBlock.fields[blockMemberIndex];
-        if (vertexMember.name != fragmentMember.name)
-        {
-            infoLog << "Name mismatch for field " << blockMemberIndex
-                    << " of interface block '" << blockName
-                    << "': (in vertex: '" << vertexMember.name
-                    << "', in fragment: '" << fragmentMember.name << "')";
-            return false;
-        }
-        std::string memberName = "interface block '" + vertexInterfaceBlock.name + "' member '" + vertexMember.name + "'";
-        if (!linkValidateInterfaceBlockFields(infoLog, memberName, vertexMember, fragmentMember,
-                                              webglCompatibility))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool Program::linkValidateVariablesBase(InfoLog &infoLog, const std::string &variableName, const sh::ShaderVariable &vertexVariable,
-                                              const sh::ShaderVariable &fragmentVariable, bool validatePrecision)
-{
-    if (vertexVariable.type != fragmentVariable.type)
-    {
-        infoLog << "Types for " << variableName << " differ between vertex and fragment shaders";
-        return false;
-    }
-    if (vertexVariable.arraySizes != fragmentVariable.arraySizes)
-    {
-        infoLog << "Array sizes for " << variableName << " differ between vertex and fragment shaders";
-        return false;
-    }
-    if (validatePrecision && vertexVariable.precision != fragmentVariable.precision)
-    {
-        infoLog << "Precisions for " << variableName << " differ between vertex and fragment shaders";
-        return false;
-    }
-    if (vertexVariable.structName != fragmentVariable.structName)
-    {
-        infoLog << "Structure names for " << variableName
-                << " differ between vertex and fragment shaders";
-        return false;
-    }
-
-    if (vertexVariable.fields.size() != fragmentVariable.fields.size())
-    {
-        infoLog << "Structure lengths for " << variableName << " differ between vertex and fragment shaders";
-        return false;
-    }
-    const unsigned int numMembers = static_cast<unsigned int>(vertexVariable.fields.size());
-    for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++)
-    {
-        const sh::ShaderVariable &vertexMember = vertexVariable.fields[memberIndex];
-        const sh::ShaderVariable &fragmentMember = fragmentVariable.fields[memberIndex];
-
-        if (vertexMember.name != fragmentMember.name)
-        {
-            infoLog << "Name mismatch for field '" << memberIndex
-                    << "' of " << variableName
-                    << ": (in vertex: '" << vertexMember.name
-                    << "', in fragment: '" << fragmentMember.name << "')";
-            return false;
-        }
-
-        const std::string memberName = variableName.substr(0, variableName.length() - 1) + "." +
-                                       vertexMember.name + "'";
-
-        if (!linkValidateVariablesBase(infoLog, vertexMember.name, vertexMember, fragmentMember, validatePrecision))
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool Program::linkValidateVaryings(InfoLog &infoLog,
-                                   const std::string &varyingName,
-                                   const sh::Varying &vertexVarying,
-                                   const sh::Varying &fragmentVarying,
-                                   int shaderVersion)
-{
-    if (!linkValidateVariablesBase(infoLog, varyingName, vertexVarying, fragmentVarying, false))
-    {
-        return false;
-    }
-
-    if (!sh::InterpolationTypesMatch(vertexVarying.interpolation, fragmentVarying.interpolation))
-    {
-        infoLog << "Interpolation types for " << varyingName
-                << " differ between vertex and fragment shaders.";
-        return false;
-    }
-
-    if (shaderVersion == 100 && vertexVarying.isInvariant != fragmentVarying.isInvariant)
-    {
-        infoLog << "Invariance for " << varyingName
-                << " differs between vertex and fragment shaders.";
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::linkValidateBuiltInVaryings(const Context *context, InfoLog &infoLog) const
-{
-    Shader *vertexShader         = mState.mAttachedVertexShader;
-    Shader *fragmentShader       = mState.mAttachedFragmentShader;
-    const auto &vertexVaryings   = vertexShader->getOutputVaryings(context);
-    const auto &fragmentVaryings = fragmentShader->getInputVaryings(context);
-    int shaderVersion            = vertexShader->getShaderVersion(context);
-
-    if (shaderVersion != 100)
-    {
-        // Only ESSL 1.0 has restrictions on matching input and output invariance
-        return true;
-    }
-
-    bool glPositionIsInvariant   = false;
-    bool glPointSizeIsInvariant  = false;
-    bool glFragCoordIsInvariant  = false;
-    bool glPointCoordIsInvariant = false;
-
-    for (const sh::Varying &varying : vertexVaryings)
-    {
-        if (!varying.isBuiltIn())
-        {
-            continue;
-        }
-        if (varying.name.compare("gl_Position") == 0)
-        {
-            glPositionIsInvariant = varying.isInvariant;
-        }
-        else if (varying.name.compare("gl_PointSize") == 0)
-        {
-            glPointSizeIsInvariant = varying.isInvariant;
-        }
-    }
-
-    for (const sh::Varying &varying : fragmentVaryings)
-    {
-        if (!varying.isBuiltIn())
-        {
-            continue;
-        }
-        if (varying.name.compare("gl_FragCoord") == 0)
-        {
-            glFragCoordIsInvariant = varying.isInvariant;
-        }
-        else if (varying.name.compare("gl_PointCoord") == 0)
-        {
-            glPointCoordIsInvariant = varying.isInvariant;
-        }
-    }
-
-    // There is some ambiguity in ESSL 1.00.17 paragraph 4.6.4 interpretation,
-    // for example, https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13842.
-    // Not requiring invariance to match is supported by:
-    // dEQP, WebGL CTS, Nexus 5X GLES
-    if (glFragCoordIsInvariant && !glPositionIsInvariant)
-    {
-        infoLog << "gl_FragCoord can only be declared invariant if and only if gl_Position is "
-                   "declared invariant.";
-        return false;
-    }
-    if (glPointCoordIsInvariant && !glPointSizeIsInvariant)
-    {
-        infoLog << "gl_PointCoord can only be declared invariant if and only if gl_PointSize is "
-                   "declared invariant.";
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::linkValidateTransformFeedback(const gl::Context *context,
-                                            InfoLog &infoLog,
-                                            const Program::MergedVaryings &varyings,
-                                            const Caps &caps) const
-{
-    size_t totalComponents = 0;
-
-    std::set<std::string> uniqueNames;
-
-    for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames)
-    {
-        bool found = false;
-        std::vector<unsigned int> subscripts;
-        std::string baseName = ParseResourceName(tfVaryingName, &subscripts);
-
-        for (const auto &ref : varyings)
-        {
-            const sh::Varying *varying = ref.second.get();
-
-            if (baseName == varying->name)
-            {
-                if (uniqueNames.count(tfVaryingName) > 0)
-                {
-                    infoLog << "Two transform feedback varyings specify the same output variable ("
-                            << tfVaryingName << ").";
-                    return false;
-                }
-                if (context->getClientVersion() >= Version(3, 1))
-                {
-                    if (IncludeSameArrayElement(uniqueNames, tfVaryingName))
-                    {
-                        infoLog
-                            << "Two transform feedback varyings include the same array element ("
-                            << tfVaryingName << ").";
-                        return false;
-                    }
-                }
-                else if (varying->isArray())
-                {
-                    infoLog << "Capture of arrays is undefined and not supported.";
-                    return false;
-                }
-
-                uniqueNames.insert(tfVaryingName);
-
-                // TODO(jmadill): Investigate implementation limits on D3D11
-
-                // GLSL ES 3.10 section 4.3.6: A vertex output can't be an array of arrays.
-                ASSERT(!varying->isArrayOfArrays());
-                size_t elementCount =
-                    ((varying->isArray() && subscripts.empty()) ? varying->getOutermostArraySize()
-                                                                : 1);
-                size_t componentCount = VariableComponentCount(varying->type) * elementCount;
-                if (mState.mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS &&
-                    componentCount > caps.maxTransformFeedbackSeparateComponents)
-                {
-                    infoLog << "Transform feedback varying's " << varying->name << " components ("
-                            << componentCount << ") exceed the maximum separate components ("
-                            << caps.maxTransformFeedbackSeparateComponents << ").";
-                    return false;
-                }
-
-                totalComponents += componentCount;
-                found = true;
-                break;
-            }
-        }
-        if (context->getClientVersion() < Version(3, 1) &&
-            tfVaryingName.find('[') != std::string::npos)
-        {
-            infoLog << "Capture of array elements is undefined and not supported.";
-            return false;
-        }
-        if (!found)
-        {
-            infoLog << "Transform feedback varying " << tfVaryingName
-                    << " does not exist in the vertex shader.";
-            return false;
-        }
-    }
-
-    if (mState.mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS &&
-        totalComponents > caps.maxTransformFeedbackInterleavedComponents)
-    {
-        infoLog << "Transform feedback varying total components (" << totalComponents
-                << ") exceed the maximum interleaved components ("
-                << caps.maxTransformFeedbackInterleavedComponents << ").";
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::linkValidateGlobalNames(const Context *context, InfoLog &infoLog) const
-{
-    const std::vector<sh::Uniform> &vertexUniforms =
-        mState.mAttachedVertexShader->getUniforms(context);
-    const std::vector<sh::Uniform> &fragmentUniforms =
-        mState.mAttachedFragmentShader->getUniforms(context);
-    const std::vector<sh::Attribute> &attributes =
-        mState.mAttachedVertexShader->getActiveAttributes(context);
-    for (const auto &attrib : attributes)
-    {
-        for (const auto &uniform : vertexUniforms)
-        {
-            if (uniform.name == attrib.name)
-            {
-                infoLog << "Name conflicts between a uniform and an attribute: " << attrib.name;
-                return false;
-            }
-        }
-        for (const auto &uniform : fragmentUniforms)
-        {
-            if (uniform.name == attrib.name)
-            {
-                infoLog << "Name conflicts between a uniform and an attribute: " << attrib.name;
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-void Program::gatherTransformFeedbackVaryings(const Program::MergedVaryings &varyings)
-{
-    // Gather the linked varyings that are used for transform feedback, they should all exist.
-    mState.mLinkedTransformFeedbackVaryings.clear();
-    for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames)
-    {
-        std::vector<unsigned int> subscripts;
-        std::string baseName = ParseResourceName(tfVaryingName, &subscripts);
-        size_t subscript     = GL_INVALID_INDEX;
-        if (!subscripts.empty())
-        {
-            subscript = subscripts.back();
-        }
-        for (const auto &ref : varyings)
-        {
-            const sh::Varying *varying = ref.second.get();
-            if (baseName == varying->name)
-            {
-                mState.mLinkedTransformFeedbackVaryings.emplace_back(
-                    *varying, static_cast<GLuint>(subscript));
-                break;
-            }
-        }
-    }
-}
-
-Program::MergedVaryings Program::getMergedVaryings(const Context *context) const
-{
-    MergedVaryings merged;
-
-    for (const sh::Varying &varying : mState.mAttachedVertexShader->getOutputVaryings(context))
-    {
-        merged[varying.name].vertex = &varying;
-    }
-
-    for (const sh::Varying &varying : mState.mAttachedFragmentShader->getInputVaryings(context))
-    {
-        merged[varying.name].fragment = &varying;
-    }
-
-    return merged;
-}
-
-
-void Program::linkOutputVariables(const Context *context)
-{
-    Shader *fragmentShader = mState.mAttachedFragmentShader;
-    ASSERT(fragmentShader != nullptr);
-
-    ASSERT(mState.mOutputVariableTypes.empty());
-    ASSERT(mState.mActiveOutputVariables.none());
-
-    // Gather output variable types
-    for (const auto &outputVariable : fragmentShader->getActiveOutputVariables(context))
-    {
-        if (outputVariable.isBuiltIn() && outputVariable.name != "gl_FragColor" &&
-            outputVariable.name != "gl_FragData")
-        {
-            continue;
-        }
-
-        unsigned int baseLocation =
-            (outputVariable.location == -1 ? 0u
-                                           : static_cast<unsigned int>(outputVariable.location));
-
-        // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of
-        // structures, so we may use getBasicTypeElementCount().
-        unsigned int elementCount = outputVariable.getBasicTypeElementCount();
-        for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
-        {
-            const unsigned int location = baseLocation + elementIndex;
-            if (location >= mState.mOutputVariableTypes.size())
-            {
-                mState.mOutputVariableTypes.resize(location + 1, GL_NONE);
-            }
-            ASSERT(location < mState.mActiveOutputVariables.size());
-            mState.mActiveOutputVariables.set(location);
-            mState.mOutputVariableTypes[location] = VariableComponentType(outputVariable.type);
-        }
-    }
-
-    // Skip this step for GLES2 shaders.
-    if (fragmentShader->getShaderVersion(context) == 100)
-        return;
-
-    mState.mOutputVariables = fragmentShader->getActiveOutputVariables(context);
-    // TODO(jmadill): any caps validation here?
-
-    for (unsigned int outputVariableIndex = 0; outputVariableIndex < mState.mOutputVariables.size();
-         outputVariableIndex++)
-    {
-        const sh::OutputVariable &outputVariable = mState.mOutputVariables[outputVariableIndex];
-
-        if (outputVariable.isArray())
-        {
-            // We're following the GLES 3.1 November 2016 spec section 7.3.1.1 Naming Active
-            // Resources and including [0] at the end of array variable names.
-            mState.mOutputVariables[outputVariableIndex].name += "[0]";
-            mState.mOutputVariables[outputVariableIndex].mappedName += "[0]";
-        }
-
-        // Don't store outputs for gl_FragDepth, gl_FragColor, etc.
-        if (outputVariable.isBuiltIn())
-            continue;
-
-        // Since multiple output locations must be specified, use 0 for non-specified locations.
-        unsigned int baseLocation =
-            (outputVariable.location == -1 ? 0u
-                                           : static_cast<unsigned int>(outputVariable.location));
-
-        // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of
-        // structures, so we may use getBasicTypeElementCount().
-        unsigned int elementCount = outputVariable.getBasicTypeElementCount();
-        for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
-        {
-            const unsigned int location = baseLocation + elementIndex;
-            if (location >= mState.mOutputLocations.size())
-            {
-                mState.mOutputLocations.resize(location + 1);
-            }
-            ASSERT(!mState.mOutputLocations.at(location).used());
-            if (outputVariable.isArray())
-            {
-                mState.mOutputLocations[location] =
-                    VariableLocation(elementIndex, outputVariableIndex);
-            }
-            else
-            {
-                VariableLocation locationInfo;
-                locationInfo.index                = outputVariableIndex;
-                mState.mOutputLocations[location] = locationInfo;
-            }
-        }
-    }
-}
-
-void Program::setUniformValuesFromBindingQualifiers()
-{
-    for (unsigned int samplerIndex : mState.mSamplerUniformRange)
-    {
-        const auto &samplerUniform = mState.mUniforms[samplerIndex];
-        if (samplerUniform.binding != -1)
-        {
-            GLint location = getUniformLocation(samplerUniform.name);
-            ASSERT(location != -1);
-            std::vector<GLint> boundTextureUnits;
-            for (unsigned int elementIndex = 0;
-                 elementIndex < samplerUniform.getBasicTypeElementCount(); ++elementIndex)
-            {
-                boundTextureUnits.push_back(samplerUniform.binding + elementIndex);
-            }
-            setUniform1iv(location, static_cast<GLsizei>(boundTextureUnits.size()),
-                          boundTextureUnits.data());
-        }
-    }
-}
-
-void Program::gatherAtomicCounterBuffers()
-{
-    for (unsigned int index : mState.mAtomicCounterUniformRange)
-    {
-        auto &uniform                      = mState.mUniforms[index];
-        uniform.blockInfo.offset           = uniform.offset;
-        uniform.blockInfo.arrayStride      = (uniform.isArray() ? 4 : 0);
-        uniform.blockInfo.matrixStride     = 0;
-        uniform.blockInfo.isRowMajorMatrix = false;
-    }
-
-    // TODO(jie.a.chen@intel.com): Get the actual BUFFER_DATA_SIZE from backend for each buffer.
-}
-
-void Program::initInterfaceBlockBindings()
-{
-    // Set initial bindings from shader.
-    for (unsigned int blockIndex = 0; blockIndex < mState.mUniformBlocks.size(); blockIndex++)
-    {
-        InterfaceBlock &uniformBlock = mState.mUniformBlocks[blockIndex];
-        bindUniformBlock(blockIndex, uniformBlock.binding);
-    }
-}
-
-void Program::updateSamplerUniform(const VariableLocation &locationInfo,
-                                   GLsizei clampedCount,
-                                   const GLint *v)
-{
-    ASSERT(mState.isSamplerUniformIndex(locationInfo.index));
-    GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(locationInfo.index);
-    std::vector<GLuint> *boundTextureUnits =
-        &mState.mSamplerBindings[samplerIndex].boundTextureUnits;
-
-    std::copy(v, v + clampedCount, boundTextureUnits->begin() + locationInfo.arrayIndex);
-
-    // Invalidate the validation cache.
-    mCachedValidateSamplersResult.reset();
-}
-
-template <typename T>
-GLsizei Program::clampUniformCount(const VariableLocation &locationInfo,
-                                   GLsizei count,
-                                   int vectorSize,
-                                   const T *v)
-{
-    if (count == 1)
-        return 1;
-
-    const LinkedUniform &linkedUniform = mState.mUniforms[locationInfo.index];
-
-    // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
-    // element index used, as reported by GetActiveUniform, will be ignored by the GL."
-    unsigned int remainingElements =
-        linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
-    GLsizei maxElementCount =
-        static_cast<GLsizei>(remainingElements * linkedUniform.getElementComponents());
-
-    if (count * vectorSize > maxElementCount)
-    {
-        return maxElementCount / vectorSize;
-    }
-
-    return count;
-}
-
-template <size_t cols, size_t rows, typename T>
-GLsizei Program::clampMatrixUniformCount(GLint location,
-                                         GLsizei count,
-                                         GLboolean transpose,
-                                         const T *v)
-{
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
-
-    if (!transpose)
-    {
-        return clampUniformCount(locationInfo, count, cols * rows, v);
-    }
-
-    const LinkedUniform &linkedUniform = mState.mUniforms[locationInfo.index];
-
-    // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
-    // element index used, as reported by GetActiveUniform, will be ignored by the GL."
-    unsigned int remainingElements =
-        linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
-    return std::min(count, static_cast<GLsizei>(remainingElements));
-}
-
-// Driver differences mean that doing the uniform value cast ourselves gives consistent results.
-// EG: on NVIDIA drivers, it was observed that getUniformi for MAX_INT+1 returned MIN_INT.
-template <typename DestT>
-void Program::getUniformInternal(const Context *context,
-                                 DestT *dataOut,
-                                 GLint location,
-                                 GLenum nativeType,
-                                 int components) const
-{
-    switch (nativeType)
-    {
-        case GL_BOOL:
-        {
-            GLint tempValue[16] = {0};
-            mProgram->getUniformiv(context, location, tempValue);
-            UniformStateQueryCastLoop<GLboolean>(
-                dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
-            break;
-        }
-        case GL_INT:
-        {
-            GLint tempValue[16] = {0};
-            mProgram->getUniformiv(context, location, tempValue);
-            UniformStateQueryCastLoop<GLint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
-                                             components);
-            break;
-        }
-        case GL_UNSIGNED_INT:
-        {
-            GLuint tempValue[16] = {0};
-            mProgram->getUniformuiv(context, location, tempValue);
-            UniformStateQueryCastLoop<GLuint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
-                                              components);
-            break;
-        }
-        case GL_FLOAT:
-        {
-            GLfloat tempValue[16] = {0};
-            mProgram->getUniformfv(context, location, tempValue);
-            UniformStateQueryCastLoop<GLfloat>(
-                dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
-            break;
-        }
-        default:
-            UNREACHABLE();
-            break;
-    }
-}
-
-bool Program::samplesFromTexture(const gl::State &state, GLuint textureID) const
-{
-    // Must be called after samplers are validated.
-    ASSERT(mCachedValidateSamplersResult.valid() && mCachedValidateSamplersResult.value());
-
-    for (const auto &binding : mState.mSamplerBindings)
-    {
-        GLenum textureType = binding.textureType;
-        for (const auto &unit : binding.boundTextureUnits)
-        {
-            GLenum programTextureID = state.getSamplerTextureId(unit, textureType);
-            if (programTextureID == textureID)
-            {
-                // TODO(jmadill): Check for appropriate overlap.
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-}  // namespace gl