Add m-esr52 at 52.6.0

1 files changed, 1984 insertions, 0 deletions

diff --git a/gfx/angle/src/tests/gl_tests/PathRenderingTest.cpp b/gfx/angle/src/tests/gl_tests/PathRenderingTest.cpp
new file mode 100755
index 000000000..962531071
--- /dev/null
+++ b/gfx/angle/src/tests/gl_tests/PathRenderingTest.cpp
@@ -0,0 +1,1984 @@
+//
+// Copyright 2016 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.
+//
+// CHROMIUMPathRenderingTest
+//   Test CHROMIUM subset of NV_path_rendering
+//   This extension allows to render geometric paths as first class GL objects.
+
+#include "test_utils/ANGLETest.h"
+#include "shader_utils.h"
+
+#include "common/angleutils.h"
+
+#include <cmath>
+#include <cstring>
+#include <cstddef>
+#include <fstream>
+
+using namespace angle;
+
+namespace
+{
+
+bool CheckPixels(GLint x,
+                 GLint y,
+                 GLsizei width,
+                 GLsizei height,
+                 GLint tolerance,
+                 const angle::GLColor &color)
+{
+    for (GLint yy = 0; yy < height; ++yy)
+    {
+        for (GLint xx = 0; xx < width; ++xx)
+        {
+            const auto px = x + xx;
+            const auto py = y + yy;
+            EXPECT_PIXEL_NEAR(px, py, color.R, color.G, color.B, color.A, tolerance);
+        }
+    }
+
+    return true;
+}
+
+void ExpectEqualMatrix(const GLfloat *expected, const GLfloat *actual)
+{
+    for (size_t i = 0; i < 16; ++i)
+    {
+        EXPECT_EQ(expected[i], actual[i]);
+    }
+}
+
+void ExpectEqualMatrix(const GLfloat *expected, const GLint *actual)
+{
+    for (size_t i = 0; i < 16; ++i)
+    {
+        EXPECT_EQ(static_cast<GLint>(std::roundf(expected[i])), actual[i]);
+    }
+}
+
+const int kResolution = 300;
+
+class CHROMIUMPathRenderingTest : public ANGLETest
+{
+  protected:
+    CHROMIUMPathRenderingTest()
+    {
+        setWindowWidth(kResolution);
+        setWindowHeight(kResolution);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(8);
+        setConfigStencilBits(8);
+    }
+
+    bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); }
+
+    void tryAllDrawFunctions(GLuint path, GLenum err)
+    {
+        glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F);
+        EXPECT_GL_ERROR(err);
+
+        glStencilFillPathCHROMIUM(path, GL_COUNT_DOWN_CHROMIUM, 0x7F);
+        EXPECT_GL_ERROR(err);
+
+        glStencilStrokePathCHROMIUM(path, 0x80, 0x80);
+        EXPECT_GL_ERROR(err);
+
+        glCoverFillPathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM);
+        EXPECT_GL_ERROR(err);
+
+        glCoverStrokePathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM);
+        EXPECT_GL_ERROR(err);
+
+        glStencilThenCoverStrokePathCHROMIUM(path, 0x80, 0x80, GL_BOUNDING_BOX_CHROMIUM);
+        EXPECT_GL_ERROR(err);
+
+        glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F,
+                                           GL_BOUNDING_BOX_CHROMIUM);
+        EXPECT_GL_ERROR(err);
+    }
+};
+
+// Test setting and getting of path rendering matrices.
+TEST_P(CHROMIUMPathRenderingTest, TestMatrix)
+{
+    if (!isApplicable())
+        return;
+
+    static const GLfloat kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
+                                                0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+
+    static const GLfloat kSeqMatrix[16] = {0.5f,   -0.5f,  -0.1f,  -0.8f, 4.4f,   5.5f,
+                                           6.6f,   7.7f,   8.8f,   9.9f,  10.11f, 11.22f,
+                                           12.33f, 13.44f, 14.55f, 15.66f};
+
+    static const GLenum kMatrixModes[] = {GL_PATH_MODELVIEW_CHROMIUM, GL_PATH_PROJECTION_CHROMIUM};
+
+    static const GLenum kGetMatrixModes[] = {GL_PATH_MODELVIEW_MATRIX_CHROMIUM,
+                                             GL_PATH_PROJECTION_MATRIX_CHROMIUM};
+
+    for (size_t i = 0; i < 2; ++i)
+    {
+        GLfloat mf[16];
+        GLint mi[16];
+        std::memset(mf, 0, sizeof(mf));
+        std::memset(mi, 0, sizeof(mi));
+        glGetFloatv(kGetMatrixModes[i], mf);
+        glGetIntegerv(kGetMatrixModes[i], mi);
+        ExpectEqualMatrix(kIdentityMatrix, mf);
+        ExpectEqualMatrix(kIdentityMatrix, mi);
+
+        glMatrixLoadfCHROMIUM(kMatrixModes[i], kSeqMatrix);
+        std::memset(mf, 0, sizeof(mf));
+        std::memset(mi, 0, sizeof(mi));
+        glGetFloatv(kGetMatrixModes[i], mf);
+        glGetIntegerv(kGetMatrixModes[i], mi);
+        ExpectEqualMatrix(kSeqMatrix, mf);
+        ExpectEqualMatrix(kSeqMatrix, mi);
+
+        glMatrixLoadIdentityCHROMIUM(kMatrixModes[i]);
+        std::memset(mf, 0, sizeof(mf));
+        std::memset(mi, 0, sizeof(mi));
+        glGetFloatv(kGetMatrixModes[i], mf);
+        glGetIntegerv(kGetMatrixModes[i], mi);
+        ExpectEqualMatrix(kIdentityMatrix, mf);
+        ExpectEqualMatrix(kIdentityMatrix, mi);
+
+        ASSERT_GL_NO_ERROR();
+    }
+}
+
+// Test that trying to set incorrect matrix target results
+// in a GL error.
+TEST_P(CHROMIUMPathRenderingTest, TestMatrixErrors)
+{
+    if (!isApplicable())
+        return;
+
+    GLfloat mf[16];
+    std::memset(mf, 0, sizeof(mf));
+
+    glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM, mf);
+    ASSERT_GL_NO_ERROR();
+
+    glMatrixLoadIdentityCHROMIUM(GL_PATH_PROJECTION_CHROMIUM);
+    ASSERT_GL_NO_ERROR();
+
+    // Test that invalid matrix targets fail.
+    glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM - 1, mf);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    // Test that invalid matrix targets fail.
+    glMatrixLoadIdentityCHROMIUM(GL_PATH_PROJECTION_CHROMIUM + 1);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+}
+
+// Test basic path create and delete.
+TEST_P(CHROMIUMPathRenderingTest, TestGenDelete)
+{
+    if (!isApplicable())
+        return;
+
+    // This is unspecified in NV_path_rendering.
+    EXPECT_EQ(0u, glGenPathsCHROMIUM(0));
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    EXPECT_NE(0u, path);
+    glDeletePathsCHROMIUM(path, 1);
+    ASSERT_GL_NO_ERROR();
+
+    GLuint first_path = glGenPathsCHROMIUM(5);
+    EXPECT_NE(0u, first_path);
+    glDeletePathsCHROMIUM(first_path, 5);
+    ASSERT_GL_NO_ERROR();
+
+    // Test deleting paths that are not actually allocated:
+    // "unused names in /paths/ are silently ignored".
+    first_path = glGenPathsCHROMIUM(5);
+    EXPECT_NE(0u, first_path);
+    glDeletePathsCHROMIUM(first_path, 6);
+    ASSERT_GL_NO_ERROR();
+
+    GLsizei big_range = 0xffff;
+    first_path = glGenPathsCHROMIUM(big_range);
+    EXPECT_NE(0u, first_path);
+    glDeletePathsCHROMIUM(first_path, big_range);
+    ASSERT_GL_NO_ERROR();
+
+    // Test glIsPathCHROMIUM(). A path object is not considered a path untill
+    // it has actually been specified with a path data.
+
+    path = glGenPathsCHROMIUM(1);
+    ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE);
+
+    // specify the data.
+    GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+    GLfloat coords[] = {50.0f, 50.0f};
+    glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords);
+    ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE);
+    glDeletePathsCHROMIUM(path, 1);
+    ASSERT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE);
+}
+
+// Test incorrect path creation and deletion and expect GL errors.
+TEST_P(CHROMIUMPathRenderingTest, TestGenDeleteErrors)
+{
+    if (!isApplicable())
+        return;
+
+    // GenPaths / DeletePaths tests.
+    // std::numeric_limits<GLuint>::max() is wrong for GLsizei.
+    GLuint first_path = glGenPathsCHROMIUM(std::numeric_limits<GLuint>::max());
+    EXPECT_EQ(first_path, 0u);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    first_path = glGenPathsCHROMIUM(-1);
+    EXPECT_EQ(0u, first_path);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    glDeletePathsCHROMIUM(1, -5);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    first_path = glGenPathsCHROMIUM(-1);
+    EXPECT_EQ(0u, first_path);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+}
+
+// Test setting and getting path parameters.
+TEST_P(CHROMIUMPathRenderingTest, TestPathParameter)
+{
+    if (!isApplicable())
+        return;
+
+    GLuint path = glGenPathsCHROMIUM(1);
+
+    // specify the data.
+    GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+    GLfloat coords[] = {50.0f, 50.0f};
+    glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords);
+    ASSERT_GL_NO_ERROR();
+    EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE);
+
+    static const GLenum kEndCaps[] = {GL_FLAT_CHROMIUM, GL_SQUARE_CHROMIUM, GL_ROUND_CHROMIUM};
+    for (std::size_t i = 0; i < 3; ++i)
+    {
+        GLint x;
+        glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, static_cast<GLenum>(kEndCaps[i]));
+        ASSERT_GL_NO_ERROR();
+        glGetPathParameterivCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, &x);
+        ASSERT_GL_NO_ERROR();
+        EXPECT_EQ(kEndCaps[i], static_cast<GLenum>(x));
+
+        GLfloat f;
+        glPathParameterfCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM,
+                                 static_cast<GLfloat>(kEndCaps[(i + 1) % 3]));
+        glGetPathParameterfvCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, &f);
+        ASSERT_GL_NO_ERROR();
+        EXPECT_EQ(kEndCaps[(i + 1) % 3], static_cast<GLenum>(f));
+    }
+
+    static const GLenum kJoinStyles[] = {GL_MITER_REVERT_CHROMIUM, GL_BEVEL_CHROMIUM,
+                                         GL_ROUND_CHROMIUM};
+    for (std::size_t i = 0; i < 3; ++i)
+    {
+        GLint x;
+        glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM,
+                                 static_cast<GLenum>(kJoinStyles[i]));
+        ASSERT_GL_NO_ERROR();
+        glGetPathParameterivCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, &x);
+        ASSERT_GL_NO_ERROR();
+        EXPECT_EQ(kJoinStyles[i], static_cast<GLenum>(x));
+
+        GLfloat f;
+        glPathParameterfCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM,
+                                 static_cast<GLfloat>(kJoinStyles[(i + 1) % 3]));
+        ASSERT_GL_NO_ERROR();
+        glGetPathParameterfvCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, &f);
+        ASSERT_GL_NO_ERROR();
+        EXPECT_EQ(kJoinStyles[(i + 1) % 3], static_cast<GLenum>(f));
+    }
+
+    {
+        glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f);
+        ASSERT_GL_NO_ERROR();
+
+        GLfloat f;
+        glGetPathParameterfvCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, &f);
+        EXPECT_EQ(5.0f, f);
+    }
+
+    glDeletePathsCHROMIUM(path, 1);
+}
+
+// Test that setting incorrect path parameter generates GL error.
+TEST_P(CHROMIUMPathRenderingTest, TestPathParameterErrors)
+{
+    if (!isApplicable())
+        return;
+
+    GLuint path = glGenPathsCHROMIUM(1);
+
+    // PathParameter*: Wrong value for the pname should fail.
+    glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, GL_FLAT_CHROMIUM);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    glPathParameterfCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, GL_MITER_REVERT_CHROMIUM);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    // PathParameter*: Wrong floating-point value should fail.
+    glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, -0.1f);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    // PathParameter*: Wrong pname should fail.
+    glPathParameteriCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM - 1, 5);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    glDeletePathsCHROMIUM(path, 1);
+}
+
+// Test expected path object state.
+TEST_P(CHROMIUMPathRenderingTest, TestPathObjectState)
+{
+    if (!isApplicable())
+        return;
+
+    glViewport(0, 0, kResolution, kResolution);
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glStencilMask(0xffffffff);
+    glClearStencil(0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    ASSERT_GL_NO_ERROR();
+
+    // Test that trying to draw non-existing paths does not produce errors or results.
+    GLuint non_existing_paths[] = {0, 55, 74744};
+    for (auto &p : non_existing_paths)
+    {
+        EXPECT_TRUE(glIsPathCHROMIUM(p) == GL_FALSE);
+        ASSERT_GL_NO_ERROR();
+        tryAllDrawFunctions(p, GL_NO_ERROR);
+    }
+
+    // Path name marked as used but without path object state causes
+    // a GL error upon any draw command.
+    GLuint path = glGenPathsCHROMIUM(1);
+    EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE);
+    tryAllDrawFunctions(path, GL_INVALID_OPERATION);
+    glDeletePathsCHROMIUM(path, 1);
+
+    // Document a bit of an inconsistency: path name marked as used but without
+    // path object state causes a GL error upon any draw command (tested above).
+    // Path name that had path object state, but then was "cleared", still has a
+    // path object state, even though the state is empty.
+    path = glGenPathsCHROMIUM(1);
+    EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_FALSE);
+
+    GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+    GLfloat coords[] = {50.0f, 50.0f};
+    glPathCommandsCHROMIUM(path, 2, commands, 2, GL_FLOAT, coords);
+    EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE);
+
+    glPathCommandsCHROMIUM(path, 0, NULL, 0, GL_FLOAT, NULL);
+    EXPECT_TRUE(glIsPathCHROMIUM(path) == GL_TRUE);  // The surprise.
+
+    tryAllDrawFunctions(path, GL_NO_ERROR);
+    glDeletePathsCHROMIUM(path, 1);
+
+    // Make sure nothing got drawn by the drawing commands that should not produce
+    // anything.
+    const angle::GLColor black = {0, 0, 0, 0};
+    EXPECT_TRUE(CheckPixels(0, 0, kResolution, kResolution, 0, black));
+}
+
+// Test that trying to use path object that doesn't exist generates
+// a GL error.
+TEST_P(CHROMIUMPathRenderingTest, TestUnnamedPathsErrors)
+{
+    if (!isApplicable())
+        return;
+
+    // Unnamed paths: Trying to create a path object with non-existing path name
+    // produces error.  (Not a error in real NV_path_rendering).
+    ASSERT_GL_NO_ERROR();
+    GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+    GLfloat coords[] = {50.0f, 50.0f};
+    glPathCommandsCHROMIUM(555, 2, commands, 2, GL_FLOAT, coords);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    // PathParameter*: Using non-existing path object produces error.
+    ASSERT_GL_NO_ERROR();
+    glPathParameterfCHROMIUM(555, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    ASSERT_GL_NO_ERROR();
+    glPathParameteriCHROMIUM(555, GL_PATH_JOIN_STYLE_CHROMIUM, GL_ROUND_CHROMIUM);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
+// Test that setting incorrect path data generates a GL error.
+TEST_P(CHROMIUMPathRenderingTest, TestPathCommandsErrors)
+{
+    if (!isApplicable())
+        return;
+
+    static const GLenum kInvalidCoordType = GL_NONE;
+
+    GLuint path        = glGenPathsCHROMIUM(1);
+    GLubyte commands[] = {GL_MOVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+    GLfloat coords[]   = {50.0f, 50.0f};
+
+    glPathCommandsCHROMIUM(path, 2, commands, -4, GL_FLOAT, coords);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    glPathCommandsCHROMIUM(path, -1, commands, 2, GL_FLOAT, coords);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    glPathCommandsCHROMIUM(path, 2, commands, 2, kInvalidCoordType, coords);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    // incorrect number of coordinates
+    glPathCommandsCHROMIUM(path, 2, commands, std::numeric_limits<GLsizei>::max(), GL_FLOAT,
+                           coords);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    // This should fail due to cmd count + coord count * short size.
+    glPathCommandsCHROMIUM(path, 2, commands, std::numeric_limits<GLsizei>::max(), GL_SHORT,
+                           coords);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    glDeletePathsCHROMIUM(path, 1);
+}
+
+// Test that trying to render a path with invalid arguments
+// generates a GL error.
+TEST_P(CHROMIUMPathRenderingTest, TestPathRenderingInvalidArgs)
+{
+    if (!isApplicable())
+        return;
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    glPathCommandsCHROMIUM(path, 0, NULL, 0, GL_FLOAT, NULL);
+
+    // Verify that normal calls work.
+    glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F);
+    ASSERT_GL_NO_ERROR();
+    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_BOUNDING_BOX_CHROMIUM);
+    ASSERT_GL_NO_ERROR();
+
+    // Using invalid fill mode causes INVALID_ENUM.
+    glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM - 1, 0x7F);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM - 1, 0x7F,
+                                       GL_BOUNDING_BOX_CHROMIUM);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    // Using invalid cover mode causes INVALID_ENUM.
+    glCoverFillPathCHROMIUM(path, GL_CONVEX_HULL_CHROMIUM - 1);
+    EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), glGetError());
+    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F,
+                                       GL_BOUNDING_BOX_CHROMIUM + 1);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    // Using mask+1 not being power of two causes INVALID_VALUE with up/down fill mode
+    glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x40);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_DOWN_CHROMIUM, 12, GL_BOUNDING_BOX_CHROMIUM);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    // check incorrect instance parameters.
+
+    // CoverFillPathInstanced
+    {
+        glCoverFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                         GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glCoverFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE,
+                                         NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_CONVEX_HULL_CHROMIUM,
+                                         GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, GL_NONE,
+                                         NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                         GL_UNSIGNED_INT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                         GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    // CoverStrokePathInstanced
+    {
+        glCoverStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glCoverStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM, GL_NONE,
+                                           NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_CONVEX_HULL_CHROMIUM,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, GL_NONE,
+                                           NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                           GL_UNSIGNED_INT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                           GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    // StencilFillPathInstanced
+    {
+        glStencilFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, GL_COUNT_UP_CHROMIUM, 0x0,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT, 0x0,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x2,
+                                           GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0,
+                                           GL_UNSIGNED_INT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_COUNT_UP_CHROMIUM, 0x0,
+                                           GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    // StencilStrokePathInstanced
+    {
+        glStencilStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00, GL_NONE,
+                                             NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, 0x00, 0x00, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, nullptr, 0, 0x00, 0x00, GL_NONE,
+                                             NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00,
+                                             GL_UNSIGNED_INT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x00, 0x00,
+                                             GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    // StencilThenCoverFillPathInstanced
+    {
+        glStencilThenCoverFillPathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0,
+                                                    GL_COUNT_UP_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM,
+                                                    GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, GL_CONVEX_HULL_CHROMIUM,
+                                                    0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0,
+                                                    GL_CONVEX_HULL_CHROMIUM, 0,
+                                                    GL_COUNT_UP_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, GL_UNSIGNED_INT,
+                                                    0, GL_COUNT_UP_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0,
+                                                    GL_CONVEX_HULL_CHROMIUM, 0, GL_UNSIGNED_INT,
+                                                    GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0,
+                                                    GL_CONVEX_HULL_CHROMIUM, 0,
+                                                    GL_COUNT_UP_CHROMIUM, GL_FLOAT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverFillPathInstancedCHROMIUM(
+            1, GL_UNSIGNED_INT, &path, 0, GL_CONVEX_HULL_CHROMIUM, 0, GL_COUNT_UP_CHROMIUM,
+            GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    // StencilThenCoverStrokePathInstanced
+    {
+        glStencilThenCoverStrokePathInstancedCHROMIUM(-1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0,
+                                                      GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_FLOAT, &path, 0, 0x0, 0x0,
+                                                      GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, NULL, 0, 0x0, 0x0,
+                                                      GL_CONVEX_HULL_CHROMIUM, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+        glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0,
+                                                      GL_FLOAT, GL_NONE, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0,
+                                                      GL_CONVEX_HULL_CHROMIUM, GL_FLOAT, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+        glStencilThenCoverStrokePathInstancedCHROMIUM(1, GL_UNSIGNED_INT, &path, 0, 0x0, 0x0,
+                                                      GL_CONVEX_HULL_CHROMIUM,
+                                                      GL_TRANSLATE_X_CHROMIUM, NULL);
+        EXPECT_GL_ERROR(GL_INVALID_VALUE);
+    }
+
+    glDeletePathsCHROMIUM(path, 1);
+}
+
+const GLfloat kProjectionMatrix[16] = {2.0f / kResolution,
+                                       0.0f,
+                                       0.0f,
+                                       0.0f,
+                                       0.0f,
+                                       2.0f / kResolution,
+                                       0.0f,
+                                       0.0f,
+                                       0.0f,
+                                       0.0f,
+                                       -1.0f,
+                                       0.0f,
+                                       -1.0f,
+                                       -1.0f,
+                                       0.0f,
+                                       1.0f};
+
+class CHROMIUMPathRenderingDrawTest : public ANGLETest
+{
+  protected:
+    CHROMIUMPathRenderingDrawTest()
+    {
+        setWindowWidth(kResolution);
+        setWindowHeight(kResolution);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(8);
+        setConfigStencilBits(8);
+    }
+
+    bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); }
+
+    void setupStateForTestPattern()
+    {
+        glViewport(0, 0, kResolution, kResolution);
+        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        glStencilMask(0xffffffff);
+        glClearStencil(0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+        glEnable(GL_STENCIL_TEST);
+
+        static const char *kVertexShaderSource =
+            "void main() {\n"
+            "  gl_Position = vec4(1.0); \n"
+            "}";
+
+        static const char *kFragmentShaderSource =
+            "precision mediump float;\n"
+            "uniform vec4 color;\n"
+            "void main() {\n"
+            "  gl_FragColor = color;\n"
+            "}";
+
+        GLuint program = CompileProgram(kVertexShaderSource, kFragmentShaderSource);
+        glUseProgram(program);
+        mColorLoc = glGetUniformLocation(program, "color");
+        glDeleteProgram(program);
+
+        // Set up orthogonal projection with near/far plane distance of 2.
+        glMatrixLoadfCHROMIUM(GL_PATH_PROJECTION_CHROMIUM, kProjectionMatrix);
+        glMatrixLoadIdentityCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM);
+
+        ASSERT_GL_NO_ERROR();
+    }
+
+    void setupPathStateForTestPattern(GLuint path)
+    {
+        static const GLubyte kCommands[] = {GL_MOVE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM,
+                                            GL_QUADRATIC_CURVE_TO_CHROMIUM,
+                                            GL_CUBIC_CURVE_TO_CHROMIUM, GL_CLOSE_PATH_CHROMIUM};
+
+        static const GLfloat kCoords[] = {50.0f, 50.0f, 75.0f, 75.0f, 100.0f, 62.5f, 50.0f,
+                                          25.5f, 0.0f,  62.5f, 50.0f, 50.0f,  25.0f, 75.0f};
+
+        glPathCommandsCHROMIUM(path, 5, kCommands, 14, GL_FLOAT, kCoords);
+        glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f);
+        glPathParameterfCHROMIUM(path, GL_PATH_MITER_LIMIT_CHROMIUM, 1.0f);
+        glPathParameterfCHROMIUM(path, GL_PATH_STROKE_BOUND_CHROMIUM, .02f);
+        glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, GL_ROUND_CHROMIUM);
+        glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, GL_SQUARE_CHROMIUM);
+        ASSERT_GL_NO_ERROR();
+    }
+
+    void verifyTestPatternFill(GLfloat flx, GLfloat fly)
+    {
+        static const GLint kFillCoords[]  = {55, 54, 50, 28, 66, 63};
+        static const angle::GLColor kBlue = {0, 0, 255, 255};
+
+        GLint x = static_cast<GLint>(flx);
+        GLint y = static_cast<GLint>(fly);
+
+        for (size_t i = 0; i < 6; i += 2)
+        {
+            GLint fx = kFillCoords[i];
+            GLint fy = kFillCoords[i + 1];
+            EXPECT_TRUE(CheckPixels(x + fx, y + fy, 1, 1, 0, kBlue));
+        }
+    }
+    void verifyTestPatternBg(GLfloat fx, GLfloat fy)
+    {
+        static const GLint kBackgroundCoords[]     = {80, 80, 20, 20, 90, 1};
+        static const angle::GLColor kExpectedColor = {0, 0, 0, 0};
+
+        GLint x = static_cast<GLint>(fx);
+        GLint y = static_cast<GLint>(fy);
+
+        for (size_t i = 0; i < 6; i += 2)
+        {
+            GLint bx = kBackgroundCoords[i];
+            GLint by = kBackgroundCoords[i + 1];
+            EXPECT_TRUE(CheckPixels(x + bx, y + by, 1, 1, 0, kExpectedColor));
+        }
+    }
+
+    void verifyTestPatternStroke(GLfloat fx, GLfloat fy)
+    {
+        GLint x = static_cast<GLint>(fx);
+        GLint y = static_cast<GLint>(fy);
+
+        // Inside the stroke we should have green.
+        static const angle::GLColor kGreen = {0, 255, 0, 255};
+        EXPECT_TRUE(CheckPixels(x + 50, y + 53, 1, 1, 0, kGreen));
+        EXPECT_TRUE(CheckPixels(x + 26, y + 76, 1, 1, 0, kGreen));
+
+        // Outside the path we should have black.
+        static const angle::GLColor black = {0, 0, 0, 0};
+        EXPECT_TRUE(CheckPixels(x + 10, y + 10, 1, 1, 0, black));
+        EXPECT_TRUE(CheckPixels(x + 80, y + 80, 1, 1, 0, black));
+    }
+
+    GLuint mColorLoc;
+};
+
+// Tests that basic path rendering functions work.
+TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRendering)
+{
+    if (!isApplicable())
+        return;
+
+    static const float kBlue[]  = {0.0f, 0.0f, 1.0f, 1.0f};
+    static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
+
+    setupStateForTestPattern();
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    setupPathStateForTestPattern(path);
+
+    // Do the stencil fill, cover fill, stencil stroke, cover stroke
+    // in unconventional order:
+    // 1) stencil the stroke in stencil high bit
+    // 2) stencil the fill in low bits
+    // 3) cover the fill
+    // 4) cover the stroke
+    // This is done to check that glPathStencilFunc works, eg the mask
+    // goes through. Stencil func is not tested ATM, for simplicity.
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF);
+    glStencilStrokePathCHROMIUM(path, 0x80, 0x80);
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F);
+    glStencilFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F);
+
+    glStencilFunc(GL_LESS, 0, 0x7F);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kBlue);
+    glCoverFillPathCHROMIUM(path, GL_BOUNDING_BOX_CHROMIUM);
+
+    glStencilFunc(GL_EQUAL, 0x80, 0x80);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kGreen);
+    glCoverStrokePathCHROMIUM(path, GL_CONVEX_HULL_CHROMIUM);
+
+    glDeletePathsCHROMIUM(path, 1);
+
+    ASSERT_GL_NO_ERROR();
+
+    // Verify the image.
+    verifyTestPatternFill(0, 0);
+    verifyTestPatternBg(0, 0);
+    verifyTestPatternStroke(0, 0);
+}
+
+// Test that StencilThen{Stroke,Fill} path rendering functions work
+TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingThenFunctions)
+{
+    if (!isApplicable())
+        return;
+
+    static float kBlue[]  = {0.0f, 0.0f, 1.0f, 1.0f};
+    static float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
+
+    setupStateForTestPattern();
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    setupPathStateForTestPattern(path);
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF);
+    glStencilFunc(GL_EQUAL, 0x80, 0x80);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kGreen);
+    glStencilThenCoverStrokePathCHROMIUM(path, 0x80, 0x80, GL_BOUNDING_BOX_CHROMIUM);
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F);
+    glStencilFunc(GL_LESS, 0, 0x7F);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kBlue);
+    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F, GL_CONVEX_HULL_CHROMIUM);
+
+    glDeletePathsCHROMIUM(path, 1);
+
+    // Verify the image.
+    verifyTestPatternFill(0, 0);
+    verifyTestPatternBg(0, 0);
+    verifyTestPatternStroke(0, 0);
+}
+
+// Tests that drawing with *Instanced functions work.
+TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingInstanced)
+{
+    if (!isApplicable())
+        return;
+
+    static const float kBlue[]  = {0.0f, 0.0f, 1.0f, 1.0f};
+    static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
+
+    setupStateForTestPattern();
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    setupPathStateForTestPattern(path);
+
+    const GLuint kPaths[]                             = {1, 1, 1, 1, 1};
+    const GLsizei kPathCount                          = 5;
+    const GLfloat kShapeSize                          = 80.0f;
+    static const GLfloat kTransforms[kPathCount * 12] = {
+        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,           0.0f,       0.0f,
+        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize,     0.0f,       0.0f,
+        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize * 2, 0.0f,       0.0f,
+        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,           kShapeSize, 0.0f,
+        1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, kShapeSize,     kShapeSize, 0.0f};
+
+    // The test pattern is the same as in the simple draw case above,
+    // except that the path is drawn kPathCount times with different offsets.
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF);
+    glStencilStrokePathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, 0x80, 0x80,
+                                         GL_AFFINE_3D_CHROMIUM, kTransforms);
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F);
+    glUniform4fv(mColorLoc, 1, kBlue);
+    glStencilFillPathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1,
+                                       GL_COUNT_UP_CHROMIUM, 0x7F, GL_AFFINE_3D_CHROMIUM,
+                                       kTransforms);
+
+    ASSERT_GL_NO_ERROR();
+
+    glStencilFunc(GL_LESS, 0, 0x7F);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glCoverFillPathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1,
+                                     GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM,
+                                     GL_AFFINE_3D_CHROMIUM, kTransforms);
+
+    ASSERT_GL_NO_ERROR();
+
+    glStencilFunc(GL_EQUAL, 0x80, 0x80);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kGreen);
+    glCoverStrokePathInstancedCHROMIUM(kPathCount, GL_UNSIGNED_INT, kPaths, path - 1,
+                                       GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM,
+                                       GL_AFFINE_3D_CHROMIUM, kTransforms);
+
+    ASSERT_GL_NO_ERROR();
+
+    glDeletePathsCHROMIUM(path, 1);
+
+    // Verify the image.
+    verifyTestPatternFill(0.0f, 0.0f);
+    verifyTestPatternBg(0.0f, 0.0f);
+    verifyTestPatternStroke(0.0f, 0.0f);
+
+    verifyTestPatternFill(kShapeSize, 0.0f);
+    verifyTestPatternBg(kShapeSize, 0.0f);
+    verifyTestPatternStroke(kShapeSize, 0.0f);
+
+    verifyTestPatternFill(kShapeSize * 2, 0.0f);
+    verifyTestPatternBg(kShapeSize * 2, 0.0f);
+    verifyTestPatternStroke(kShapeSize * 2, 0.0f);
+
+    verifyTestPatternFill(0.0f, kShapeSize);
+    verifyTestPatternBg(0.0f, kShapeSize);
+    verifyTestPatternStroke(0.0f, kShapeSize);
+
+    verifyTestPatternFill(kShapeSize, kShapeSize);
+    verifyTestPatternBg(kShapeSize, kShapeSize);
+    verifyTestPatternStroke(kShapeSize, kShapeSize);
+}
+
+// Test that instanced fill/stroke then cover functions work.
+TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRenderingThenFunctionsInstanced)
+{
+    if (!isApplicable())
+        return;
+
+    static const float kBlue[]  = {0.0f, 0.0f, 1.0f, 1.0f};
+    static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
+
+    setupStateForTestPattern();
+
+    GLuint path = glGenPathsCHROMIUM(1);
+    setupPathStateForTestPattern(path);
+
+    const GLuint kPaths[]              = {1, 1, 1, 1, 1};
+    const GLsizei kPathCount           = 5;
+    const GLfloat kShapeSize           = 80.0f;
+    static const GLfloat kTransforms[] = {
+        0.0f, 0.0f, kShapeSize, 0.0f,       kShapeSize * 2,
+        0.0f, 0.0f, kShapeSize, kShapeSize, kShapeSize,
+    };
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0xFF);
+    glStencilFunc(GL_EQUAL, 0x80, 0x80);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kGreen);
+    glStencilThenCoverStrokePathInstancedCHROMIUM(
+        kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, 0x80, 0x80,
+        GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_TRANSLATE_2D_CHROMIUM, kTransforms);
+
+    ASSERT_GL_NO_ERROR();
+
+    glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F);
+    glStencilFunc(GL_LESS, 0, 0x7F);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+    glUniform4fv(mColorLoc, 1, kBlue);
+    glStencilThenCoverFillPathInstancedCHROMIUM(
+        kPathCount, GL_UNSIGNED_INT, kPaths, path - 1, GL_COUNT_UP_CHROMIUM, 0x7F,
+        GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_TRANSLATE_2D_CHROMIUM, kTransforms);
+
+    ASSERT_GL_NO_ERROR();
+
+    glDeletePathsCHROMIUM(path, 1);
+
+    // Verify the image.
+    verifyTestPatternFill(0.0f, 0.0f);
+    verifyTestPatternBg(0.0f, 0.0f);
+    verifyTestPatternStroke(0.0f, 0.0f);
+
+    verifyTestPatternFill(kShapeSize, 0.0f);
+    verifyTestPatternBg(kShapeSize, 0.0f);
+    verifyTestPatternStroke(kShapeSize, 0.0f);
+
+    verifyTestPatternFill(kShapeSize * 2, 0.0f);
+    verifyTestPatternBg(kShapeSize * 2, 0.0f);
+    verifyTestPatternStroke(kShapeSize * 2, 0.0f);
+
+    verifyTestPatternFill(0.0f, kShapeSize);
+    verifyTestPatternBg(0.0f, kShapeSize);
+    verifyTestPatternStroke(0.0f, kShapeSize);
+
+    verifyTestPatternFill(kShapeSize, kShapeSize);
+    verifyTestPatternBg(kShapeSize, kShapeSize);
+    verifyTestPatternStroke(kShapeSize, kShapeSize);
+}
+
+
+// This class implements a test that draws a grid of v-shapes. The grid is
+// drawn so that even rows (from the bottom) are drawn with DrawArrays and odd
+// rows are drawn with path rendering.  It can be used to test various texturing
+// modes, comparing how the fill would work in normal GL rendering and how to
+// setup same sort of fill with path rendering.
+// The texturing test is parametrized to run the test with and without
+// ANGLE name hashing.
+class CHROMIUMPathRenderingWithTexturingTest : public ANGLETest
+{
+  protected:
+    CHROMIUMPathRenderingWithTexturingTest() : mProgram(0)
+    {
+        setWindowWidth(kResolution);
+        setWindowHeight(kResolution);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(8);
+        setConfigStencilBits(8);
+    }
+
+    bool isApplicable() const { return extensionEnabled("GL_CHROMIUM_path_rendering"); }
+
+    void TearDown() override
+    {
+        if (mProgram)
+        {
+            glDeleteProgram(mProgram);
+            ASSERT_GL_NO_ERROR();
+        }
+
+        ANGLETest::TearDown();
+    }
+
+    void SetUp() override
+    {
+        ANGLETest::SetUp();
+        mBindUniformLocation = reinterpret_cast<PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC>(
+            eglGetProcAddress("glBindUniformLocationCHROMIUM"));
+    }
+
+    // Sets up the GL program state for the test.
+    // Vertex shader needs at least following variables:
+    //  uniform mat4 view_matrix;
+    //  uniform mat? color_matrix; (accessible with kColorMatrixLocation)
+    //  uniform vec2 model_translate;
+    //  attribute vec2 position;
+    //  varying vec4 color;
+    //
+    // Fragment shader needs at least following variables:
+    //  varying vec4 color;
+    //
+    //  (? can be anything)
+    void compileProgram(const char *vertexShaderSource, const char *fragmentShaderSource)
+    {
+        glViewport(0, 0, kResolution, kResolution);
+        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        glStencilMask(0xffffffff);
+        glClearStencil(0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        ASSERT_GL_NO_ERROR();
+
+        GLuint vShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
+        GLuint fShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
+        ASSERT_NE(0u, vShader);
+        ASSERT_NE(0u, fShader);
+
+        mProgram = glCreateProgram();
+
+        glAttachShader(mProgram, vShader);
+        glAttachShader(mProgram, fShader);
+        glDeleteShader(vShader);
+        glDeleteShader(fShader);
+
+        ASSERT_GL_NO_ERROR();
+    }
+
+    void bindProgram()
+    {
+        glBindAttribLocation(mProgram, kPositionLocation, "position");
+        mBindUniformLocation(mProgram, kViewMatrixLocation, "view_matrix");
+        mBindUniformLocation(mProgram, kColorMatrixLocation, "color_matrix");
+        mBindUniformLocation(mProgram, kModelTranslateLocation, "model_translate");
+        glBindFragmentInputLocationCHROMIUM(mProgram, kColorFragmentInputLocation, "color");
+
+        ASSERT_GL_NO_ERROR();
+    }
+
+    bool linkProgram()
+    {
+        glLinkProgram(mProgram);
+
+        GLint linked = 0;
+        glGetProgramiv(mProgram, GL_LINK_STATUS, &linked);
+        if (linked)
+        {
+            glUseProgram(mProgram);
+        }
+
+        return (linked == 1);
+    }
+
+    void drawTestPattern()
+    {
+        // This v-shape is used both for DrawArrays and path rendering.
+        static const GLfloat kVertices[] = {75.0f, 75.0f, 50.0f, 25.5f, 50.0f, 50.0f, 25.0f, 75.0f};
+
+        GLuint vbo = 0;
+        glGenBuffers(1, &vbo);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices, GL_STATIC_DRAW);
+        glEnableVertexAttribArray(kPositionLocation);
+        glVertexAttribPointer(kPositionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
+
+        // Setup state for drawing the shape with path rendering.
+        glPathStencilFuncCHROMIUM(GL_ALWAYS, 0, 0x7F);
+        glStencilFunc(GL_LESS, 0, 0x7F);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
+        glMatrixLoadfCHROMIUM(GL_PATH_PROJECTION_CHROMIUM, kProjectionMatrix);
+        glMatrixLoadIdentityCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM);
+
+        static const GLubyte kCommands[] = {GL_MOVE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM,
+                                            GL_LINE_TO_CHROMIUM, GL_LINE_TO_CHROMIUM,
+                                            GL_CLOSE_PATH_CHROMIUM};
+
+        static const GLfloat kCoords[] = {
+            kVertices[0], kVertices[1], kVertices[2], kVertices[3],
+            kVertices[6], kVertices[7], kVertices[4], kVertices[5],
+        };
+
+        GLuint path = glGenPathsCHROMIUM(1);
+        glPathCommandsCHROMIUM(path, static_cast<GLsizei>(ArraySize(kCommands)), kCommands,
+            static_cast<GLsizei>(ArraySize(kCoords)), GL_FLOAT, kCoords);
+        ASSERT_GL_NO_ERROR();
+
+        GLfloat path_model_translate[16] = {
+            1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
+            0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+        };
+
+        // Draws the shapes. Every even row from the bottom is drawn with
+        // DrawArrays, odd row with path rendering. The shader program is
+        // the same for the both draws.
+        for (int j = 0; j < kTestRows; ++j)
+        {
+            for (int i = 0; i < kTestColumns; ++i)
+            {
+                if (j % 2 == 0)
+                {
+                    glDisable(GL_STENCIL_TEST);
+                    glUniform2f(kModelTranslateLocation, static_cast<GLfloat>(i * kShapeWidth),
+                                static_cast<GLfloat>(j * kShapeHeight));
+                    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+                }
+                else
+                {
+                    glEnable(GL_STENCIL_TEST);
+                    path_model_translate[12] = static_cast<GLfloat>(i * kShapeWidth);
+                    path_model_translate[13] = static_cast<GLfloat>(j * kShapeHeight);
+                    glMatrixLoadfCHROMIUM(GL_PATH_MODELVIEW_CHROMIUM, path_model_translate);
+                    glStencilThenCoverFillPathCHROMIUM(path, GL_COUNT_UP_CHROMIUM, 0x7F,
+                                                       GL_BOUNDING_BOX_CHROMIUM);
+                }
+            }
+        }
+        ASSERT_GL_NO_ERROR();
+
+        glDisableVertexAttribArray(kPositionLocation);
+        glDeleteBuffers(1, &vbo);
+        glDeletePathsCHROMIUM(path, 1);
+        ASSERT_GL_NO_ERROR();
+    }
+
+    enum
+    {
+        kShapeWidth  = 75,
+        kShapeHeight = 75,
+        kTestRows    = kResolution / kShapeHeight,
+        kTestColumns = kResolution / kShapeWidth,
+    };
+
+    typedef void(GL_APIENTRYP PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC)(GLuint mProgram,
+                                                                    GLint location,
+                                                                    const GLchar *name);
+    PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC mBindUniformLocation = nullptr;
+
+    GLuint mProgram;
+
+    // This uniform be can set by the test. It should be used to set the color for
+    // drawing with DrawArrays.
+    static const GLint kColorMatrixLocation = 4;
+
+    // This fragment input can be set by the test. It should be used to set the
+    // color for drawing with path rendering.
+    static const GLint kColorFragmentInputLocation = 7;
+
+    static const GLint kModelTranslateLocation = 3;
+    static const GLint kPositionLocation       = 0;
+    static const GLint kViewMatrixLocation     = 7;
+};
+
+// Test success and error cases for binding fragment input location.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestBindFragmentInputLocation)
+{
+    if (!isApplicable())
+        return;
+
+    // original NV_path_rendering specification doesn't define whether the
+    // fragment shader input variables should be defined in the vertex shader or
+    // not. In fact it doesn't even require a vertex shader.
+    // However the GLES3.1 spec basically says that fragment inputs are
+    // either built-ins or come from the previous shader stage.
+    // (§ 14.1, Fragment Shader Variables).
+    // Additionally there are many places that are based on the assumption of having
+    // a vertex shader (command buffer, angle) so we're going to stick to the same
+    // semantics and require a vertex shader and to have the vertex shader define the
+    // varying fragment shader input.
+
+    // clang-format off
+    const char* kVertexShaderSource =
+       "varying vec4 color;\n"
+       "void main() {}\n";
+
+    const char* kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec4 color;\n"
+        "void main() {\n"
+        "  gl_FragColor = vec4(1.0);\n"
+        "}\n";
+
+    // clang-format on
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+
+    enum kBindLocations
+    {
+        kColorLocation     = 5,
+        kFragColorLocation = 6
+    };
+
+    // successful bind.
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorLocation, "color");
+    ASSERT_GL_NO_ERROR();
+
+    // any name can be bound and names that do not actually exist in the program after
+    // linking are ignored.
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorLocation, "doesnt_exist");
+    ASSERT_GL_NO_ERROR();
+
+    // illegal program
+    glBindFragmentInputLocationCHROMIUM(mProgram + 1, kColorLocation, "color");
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    // illegal bind (built-in)
+    glBindFragmentInputLocationCHROMIUM(mProgram, kFragColorLocation, "gl_FragColor");
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    glBindFragmentInputLocationCHROMIUM(mProgram, kFragColorLocation, NULL);
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    glBindFragmentInputLocationCHROMIUM(mProgram, 0xffffff, "color");
+    EXPECT_GL_ERROR(GL_INVALID_VALUE);
+
+    ASSERT_TRUE(linkProgram() == true);
+
+    const GLfloat kCoefficients16[] = {1.0f, 2.0f,  3.0f,  4.0f,  5.0f,  6.0f,  7.0f,  8.0f,
+                                       9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorLocation, GL_EYE_LINEAR_CHROMIUM, 4,
+                                          kCoefficients16);
+    ASSERT_GL_NO_ERROR();
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_EYE_LINEAR_CHROMIUM, 4, kCoefficients16);
+    ASSERT_GL_NO_ERROR();
+}
+
+// Test fragment input interpolation in CHROMIUM_EYE coordinates.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenCHROMIUM_EYE)
+{
+    if (!isApplicable())
+        return;
+
+    // clang-format off
+    const char *kVertexShaderSource =
+        "uniform mat4 view_matrix;\n"
+        "uniform mat4 color_matrix;\n"
+        "uniform vec2 model_translate;\n"
+        "attribute vec2 position;\n"
+        "varying vec3 color;\n"
+        "void main() {\n"
+        "  vec4 p = vec4(model_translate + position, 1.0, 1.0);\n"
+        "  color = (color_matrix * p).rgb;\n"
+        "  gl_Position = view_matrix * p;\n"
+        "}\n";
+
+    const char *kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec3 color;\n"
+        "void main() {\n"
+        "  gl_FragColor = vec4(color, 1.0);\n"
+        "}\n";
+    // clang-format on
+
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+    bindProgram();
+    ASSERT_TRUE(linkProgram() == true);
+
+    glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix);
+
+    static const GLfloat kColorMatrix[16] = {
+        1.0f / kResolution, 0.0f, 0.0f, 0.0f,
+        0.0f, 1.0f / kResolution, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f};
+
+    glUniformMatrix4fv(kColorMatrixLocation, 1, GL_FALSE, kColorMatrix);
+
+    // This is the functionality we are testing: ProgramPathFragmentInputGen
+    // does the same work as the color transform in vertex shader.
+    static const GLfloat kColorCoefficients[12] = {
+        1.0f / kResolution, 0.0f, 0.0f,
+        0.0f, 0.0f, 1.0f / kResolution,
+        0.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f};
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation,
+                                          GL_EYE_LINEAR_CHROMIUM, 3, kColorCoefficients);
+    ASSERT_GL_NO_ERROR();
+
+    drawTestPattern();
+
+    const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f};
+
+    for (int j = 0; j < kTestRows; ++j)
+    {
+        for (int i = 0; i < kTestColumns; ++i)
+        {
+            for (size_t k = 0; k < ArraySize(kFillCoords); k += 2)
+            {
+                const float fx = kFillCoords[k];
+                const float fy = kFillCoords[k + 1];
+                const float px = static_cast<float>(i * kShapeWidth);
+                const float py = static_cast<float>(j * kShapeHeight);
+
+                angle::GLColor color;
+                color.R = static_cast<GLubyte>(std::roundf((px + fx) / kResolution * 255.0f));
+                color.G = static_cast<GLubyte>(std::roundf((py + fy) / kResolution * 255.0f));
+                color.B = 0;
+                color.A = 255;
+                CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2,
+                            color);
+            }
+        }
+    }
+}
+
+// Test fragment input interpolation in CHROMIUM_OBJECT coordinates.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenCHROMIUM_OBJECT)
+{
+    if (!isApplicable())
+        return;
+
+    // clang-format off
+    const char *kVertexShaderSource =
+        "uniform mat4 view_matrix;\n"
+        "uniform mat4 color_matrix;\n"
+        "uniform vec2 model_translate;\n"
+        "attribute vec2 position;\n"
+        "varying vec3 color;\n"
+        "void main() {\n"
+        "  color = (color_matrix * vec4(position, 1.0, 1.0)).rgb;\n"
+        "  vec4 p = vec4(model_translate + position, 1.0, 1.0);\n"
+        "  gl_Position = view_matrix * p;\n"
+        "}";
+
+    const char *kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec3 color;\n"
+        "void main() {\n"
+        "  gl_FragColor = vec4(color.rgb, 1.0);\n"
+        "}";
+    // clang-format on
+
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+    bindProgram();
+    ASSERT_TRUE(linkProgram() == true);
+
+    glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix);
+
+    static const GLfloat kColorMatrix[16] = {
+        1.0f / kShapeWidth, 0.0f, 0.0f, 0.0f,
+        0.0f, 1.0f / kShapeHeight, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.0f, 0.0f };
+    glUniformMatrix4fv(kColorMatrixLocation, 1, GL_FALSE, kColorMatrix);
+
+    // This is the functionality we are testing: ProgramPathFragmentInputGen
+    // does the same work as the color transform in vertex shader.
+    static const GLfloat kColorCoefficients[9] = {
+        1.0f / kShapeWidth, 0.0f, 0.0f, 0.0f, 1.0f / kShapeHeight, 0.0f, 0.0f, 0.0f, 0.0f};
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation,
+                                          GL_OBJECT_LINEAR_CHROMIUM, 3, kColorCoefficients);
+
+    ASSERT_GL_NO_ERROR();
+
+    drawTestPattern();
+
+    const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f};
+
+    for (int j = 0; j < kTestRows; ++j)
+    {
+        for (int i = 0; i < kTestColumns; ++i)
+        {
+            for (size_t k = 0; k < ArraySize(kFillCoords); k += 2)
+            {
+                const float fx = kFillCoords[k];
+                const float fy = kFillCoords[k + 1];
+                const float px = static_cast<float>(i * kShapeWidth);
+                const float py = static_cast<float>(j * kShapeHeight);
+
+                angle::GLColor color;
+                color.R = static_cast<GLubyte>(std::roundf(fx / kShapeWidth * 255.0f));
+                color.G = static_cast<GLubyte>(std::roundf(fy / kShapeHeight * 255.0f));
+                color.B = 0;
+                color.A = 255;
+                CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2,
+                            color);
+            }
+        }
+    }
+}
+
+// Test success and error cases for setting interpolation parameters.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestProgramPathFragmentInputGenArgs)
+{
+    if (!isApplicable())
+        return;
+
+    // clang-format off
+    const char *kVertexShaderSource =
+        "varying vec2 vec2_var;\n"
+        "varying vec3 vec3_var;\n"
+        "varying vec4 vec4_var;\n"
+        "varying float float_var;\n"
+        "varying mat2 mat2_var;\n"
+        "varying mat3 mat3_var;\n"
+        "varying mat4 mat4_var;\n"
+        "attribute float avoid_opt;\n"
+        "void main() {\n"
+        "  vec2_var = vec2(1.0, 2.0 + avoid_opt);\n"
+        "  vec3_var = vec3(1.0, 2.0, 3.0 + avoid_opt);\n"
+        "  vec4_var = vec4(1.0, 2.0, 3.0, 4.0 + avoid_opt);\n"
+        "  float_var = 5.0 + avoid_opt;\n"
+        "  mat2_var = mat2(2.0 + avoid_opt);\n"
+        "  mat3_var = mat3(3.0 + avoid_opt);\n"
+        "  mat4_var = mat4(4.0 + avoid_opt);\n"
+        "  gl_Position = vec4(1.0);\n"
+        "}";
+
+    const char* kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec2 vec2_var;\n"
+        "varying vec3 vec3_var;\n"
+        "varying vec4 vec4_var;\n"
+        "varying float float_var;\n"
+        "varying mat2 mat2_var;\n"
+        "varying mat3 mat3_var;\n"
+        "varying mat4 mat4_var;\n"
+        "void main() {\n"
+        "  gl_FragColor = vec4(vec2_var, 0, 0) + vec4(vec3_var, 0) + vec4_var + "
+        "               vec4(float_var) + "
+        "               vec4(mat2_var[0][0], mat3_var[1][1], mat4_var[2][2], 1);\n"
+        "}";
+    // clang-format on
+
+    enum
+    {
+        kVec2Location = 0,
+        kVec3Location,
+        kVec4Location,
+        kFloatLocation,
+        kMat2Location,
+        kMat3Location,
+        kMat4Location,
+    };
+    struct
+    {
+        GLint location;
+        const char *name;
+        GLint components;
+    } variables[] = {
+        {kVec2Location, "vec2_var", 2},
+        {kVec3Location, "vec3_var", 3},
+        {kVec4Location, "vec4_var", 4},
+        {kFloatLocation, "float_var", 1},
+        // If a varying is not single-precision floating-point scalar or
+        // vector, it always causes an invalid operation.
+        {kMat2Location, "mat2_var", -1},
+        {kMat3Location, "mat3_var", -1},
+        {kMat4Location, "mat4_var", -1},
+    };
+
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+
+    for (size_t i = 0; i < ArraySize(variables); ++i)
+    {
+        glBindFragmentInputLocationCHROMIUM(mProgram, variables[i].location, variables[i].name);
+    }
+
+    // test that using invalid (not linked) program is an invalid operation.
+    // See similar calls at the end of the test for discussion about the arguments.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_NONE, 0, NULL);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+
+    ASSERT_TRUE(linkProgram() == true);
+
+    const GLfloat kCoefficients16[] = {1.0f, 2.0f,  3.0f,  4.0f,  5.0f,  6.0f,  7.0f,  8.0f,
+                                       9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
+    const GLenum kGenModes[] = {GL_NONE, GL_EYE_LINEAR_CHROMIUM, GL_OBJECT_LINEAR_CHROMIUM,
+                                GL_CONSTANT_CHROMIUM};
+
+    for (size_t variable = 0; variable < ArraySize(variables); ++variable)
+    {
+        for (GLint components = 0; components <= 4; ++components)
+        {
+            for (size_t genmode = 0; genmode < ArraySize(kGenModes); ++genmode)
+            {
+                glProgramPathFragmentInputGenCHROMIUM(mProgram, variables[variable].location,
+                                                      kGenModes[genmode], components,
+                                                      kCoefficients16);
+
+                if (components == 0 && kGenModes[genmode] == GL_NONE)
+                {
+                    if (variables[variable].components == -1)
+                    {
+                        // Clearing a fragment input that is not single-precision floating
+                        // point scalar or vector is an invalid operation.
+                        ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+                    }
+                    else
+                    {
+                        // Clearing a valid fragment input is ok.
+                        ASSERT_GL_NO_ERROR();
+                    }
+                }
+                else if (components == 0 || kGenModes[genmode] == GL_NONE)
+                {
+                    ASSERT_GL_ERROR(GL_INVALID_VALUE);
+                }
+                else
+                {
+                    if (components == variables[variable].components)
+                    {
+                        // Setting a generator for a single-precision floating point
+                        // scalar or vector fragment input is ok.
+                        ASSERT_GL_NO_ERROR();
+                    }
+                    else
+                    {
+                        // Setting a generator when components do not match is an invalid operation.
+                        ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+                    }
+                }
+            }
+        }
+    }
+
+    enum
+    {
+        kValidGenMode      = GL_CONSTANT_CHROMIUM,
+        kValidComponents   = 3,
+        kInvalidGenMode    = 0xAB,
+        kInvalidComponents = 5,
+    };
+
+    // The location == -1 would mean fragment input was optimized away. At the
+    // time of writing, -1 can not happen because the only way to obtain the
+    // location numbers is through bind. Test just to be consistent.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kValidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_NO_ERROR();
+
+    // Test that even though the spec says location == -1 causes the operation to
+    // be skipped, the verification of other parameters is still done. This is a
+    // GL policy.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kValidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_ENUM);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kInvalidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_ENUM);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kInvalidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_VALUE);
+
+    glDeleteProgram(mProgram);
+
+    // Test that using invalid (deleted) program is an invalid operation.
+    EXPECT_FALSE(glIsProgram(mProgram) == GL_FALSE);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kValidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kValidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kInvalidGenMode, kInvalidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, kValidGenMode, kInvalidComponents,
+                                          kCoefficients16);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+
+    mProgram = 0u;
+}
+
+// Test that having input statically aliased fragment inputs the linking fails
+// and then succeeds when the conflict is resolved.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, TestConflictingBind)
+{
+    if (!isApplicable())
+        return;
+
+    // clang-format off
+    const char* kVertexShaderSource =
+        "attribute vec4 position;\n"
+        "varying vec4 colorA;\n"
+        "varying vec4 colorB;\n"
+        "void main() {\n"
+        "  gl_Position = position;\n"
+        "  colorA = position + vec4(1);\n"
+        "  colorB = position + vec4(2);\n"
+        "}";
+
+    const char* kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec4 colorA;\n"
+        "varying vec4 colorB;\n"
+        "void main() {\n"
+        "  gl_FragColor = colorA + colorB;\n"
+        "}";
+    // clang-format on
+
+    const GLint kColorALocation = 3;
+    const GLint kColorBLocation = 4;
+
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorALocation, "colorA");
+    // Bind colorB to location a, causing conflicts. Linking should fail.
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorALocation, "colorB");
+
+    // Should fail now.
+    ASSERT_TRUE(linkProgram() == false);
+    ASSERT_GL_NO_ERROR();
+
+    // Resolve the bind conflict.
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorBLocation, "colorB");
+
+    ASSERT_TRUE(linkProgram() == true);
+    ASSERT_GL_NO_ERROR();
+}
+
+// Test binding with array variables, using zero indices. Tests that
+// binding colorA[0] with explicit "colorA[0]" as well as "colorA" produces
+// a correct location that can be used with PathProgramFragmentInputGen.
+// For path rendering, colorA[0] is bound to a location. The input generator for
+// the location is set to produce vec4(0, 0.1, 0, 0.1).
+// The default varying, color, is bound to a location and its generator
+// will produce vec4(10.0).  The shader program produces green pixels.
+// For vertex-based rendering, the vertex shader produces the same effect as
+// the input generator for path rendering.
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, BindFragmentInputArray)
+{
+    if (!isApplicable())
+        return;
+
+    //clang-format off
+    const char* kVertexShaderSource =
+        "uniform mat4 view_matrix;\n"
+        "uniform mat4 color_matrix;\n"
+        "uniform vec2 model_translate;\n"
+        "attribute vec2 position;\n"
+        "varying vec4 color;\n"
+        "varying vec4 colorA[4];\n"
+        "void main() {\n"
+        "  vec4 p = vec4(model_translate + position, 1, 1);\n"
+        "  gl_Position = view_matrix * p;\n"
+        "  colorA[0] = vec4(0.0, 0.1, 0, 0.1);\n"
+        "  colorA[1] = vec4(0.2);\n"
+        "  colorA[2] = vec4(0.3);\n"
+        "  colorA[3] = vec4(0.4);\n"
+        "  color = vec4(10.0);\n"
+        "}";
+
+    const char* kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec4 color;\n"
+        "varying vec4 colorA[4];\n"
+        "void main() {\n"
+        "  gl_FragColor = colorA[0] * color;\n"
+        "}";
+    // clang-format on
+
+    const GLint kColorA0Location = 4;
+    const GLint kUnusedLocation  = 5;
+    const GLfloat kColorA0[]     = {0.0f, 0.1f, 0.0f, 0.1f};
+    const GLfloat kColor[]       = {10.0f, 10.0f, 10.0f, 10.0f};
+    const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f};
+
+    for (int pass = 0; pass < 2; ++pass)
+    {
+        compileProgram(kVertexShaderSource, kFragmentShaderSource);
+        if (pass == 0)
+        {
+            glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA[0]");
+            glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA");
+        }
+        else
+        {
+            glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA");
+            glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA[0]");
+        }
+
+        bindProgram();
+
+        ASSERT_TRUE(linkProgram() == true);
+
+        glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix);
+        glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA0Location, GL_CONSTANT_CHROMIUM, 4, kColorA0);
+        glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation, GL_CONSTANT_CHROMIUM, 4, kColor);
+        ASSERT_GL_NO_ERROR();
+
+        drawTestPattern();
+
+        for (int j = 0; j < kTestRows; ++j)
+        {
+            for (int i = 0; i < kTestColumns; ++i)
+            {
+                for (size_t k = 0; k < ArraySize(kFillCoords); k += 2)
+                {
+                    const float fx = kFillCoords[k];
+                    const float fy = kFillCoords[k + 1];
+                    const float px = static_cast<float>(i * kShapeWidth);
+                    const float py = static_cast<float>(j * kShapeHeight);
+
+                    angle::GLColor color;
+                    color.R = 0;
+                    color.G = 255;
+                    color.B = 0;
+                    color.A = 255;
+                    CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2,
+                                color);
+                }
+            }
+        }
+    }
+}
+
+// Test binding array variables. This is like BindFragmentInputArray.
+// Currently disabled since it seems there's a driver bug with the
+// older drivers. This should work with driver >= 364.12
+TEST_P(CHROMIUMPathRenderingWithTexturingTest,
+    DISABLED_BindFragmentInputArrayNonZeroIndex)
+{
+    if (!isApplicable())
+        return;
+
+    // clang-format off
+    const char* kVertexShaderSource =
+        "uniform mat4 view_matrix;\n"
+        "uniform mat4 color_matrix;\n"
+        "uniform vec2 model_translate;\n"
+        "attribute vec2 position;\n"
+        "varying vec4 color;\n"
+        "varying vec4 colorA[4];\n"
+        "void main() {\n"
+        "  vec4 p = vec4(model_translate + position, 1, 1);\n"
+        "  gl_Position = view_matrix * p;\n"
+        "  colorA[0] = vec4(0, 0.1, 0, 0.1);\n"
+        "  colorA[1] = vec4(0, 1, 0, 1);\n"
+        "  colorA[2] = vec4(0, 0.8, 0, 0.8);\n"
+        "  colorA[3] = vec4(0, 0.5, 0, 0.5);\n"
+        "  color = vec4(0.2);\n"
+        "}\n";
+
+    const char* kFragmentShaderSource =
+        "precision mediump float;\n"
+        "varying vec4 colorA[4];\n"
+        "varying vec4 color;\n"
+        "void main() {\n"
+        "  gl_FragColor = (colorA[0] * colorA[1]) +\n"
+        "      colorA[2] + (colorA[3] * color);\n"
+        "}\n";
+    // clang-format on
+
+    const GLint kColorA0Location = 4;
+    const GLint kColorA1Location = 1;
+    const GLint kColorA2Location = 2;
+    const GLint kColorA3Location = 3;
+    const GLint kUnusedLocation = 5;
+    const GLfloat kColorA0[] = {0.0f, 0.1f, 0.0f, 0.1f};
+    const GLfloat kColorA1[] = {0.0f, 1.0f, 0.0f, 1.0f};
+    const GLfloat kColorA2[] = {0.0f, 0.8f, 0.0f, 0.8f};
+    const GLfloat kColorA3[] = {0.0f, 0.5f, 0.0f, 0.5f};
+    const GLfloat kColor[] = {0.2f, 0.2f, 0.2f, 0.2f};
+    const GLfloat kFillCoords[6] = {59.0f, 50.0f, 50.0f, 28.0f, 66.0f, 63.0f};
+
+    compileProgram(kVertexShaderSource, kFragmentShaderSource);
+
+    glBindFragmentInputLocationCHROMIUM(mProgram, kUnusedLocation, "colorA[0]");
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorA1Location, "colorA[1]");
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorA2Location, "colorA[2]");
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorA3Location, "colorA[3]");
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorA0Location, "colorA");
+    ASSERT_GL_NO_ERROR();
+
+    bindProgram();
+    ASSERT_TRUE(linkProgram() == true);
+
+    glUniformMatrix4fv(kViewMatrixLocation, 1, GL_FALSE, kProjectionMatrix);
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA0Location, GL_CONSTANT_CHROMIUM, 4, kColorA0);
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA1Location, GL_CONSTANT_CHROMIUM, 4, kColorA1);
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA2Location, GL_CONSTANT_CHROMIUM, 4, kColorA2);
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorA3Location, GL_CONSTANT_CHROMIUM, 4, kColorA3);
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorFragmentInputLocation,
+        GL_CONSTANT_CHROMIUM, 4, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    drawTestPattern();
+
+    for (int j = 0; j < kTestRows; ++j)
+    {
+        for (int i = 0; i < kTestColumns; ++i)
+        {
+            for (size_t k = 0; k < ArraySize(kFillCoords); k += 2)
+            {
+                const float fx = kFillCoords[k];
+                const float fy = kFillCoords[k + 1];
+                const float px = static_cast<float>(i * kShapeWidth);
+                const float py = static_cast<float>(j * kShapeHeight);
+
+                angle::GLColor color;
+                color.R = 0;
+                color.G = 255;
+                color.B = 0;
+                color.A = 255;
+                CheckPixels(static_cast<GLint>(px + fx), static_cast<GLint>(py + fy), 1, 1, 2,
+                            color);
+            }
+        }
+    }
+}
+
+TEST_P(CHROMIUMPathRenderingWithTexturingTest, UnusedFragmentInputUpdate)
+{
+    if (!isApplicable())
+        return;
+
+  // clang-format off
+    const char* kVertexShaderString =
+        "attribute vec4 a_position;\n"
+        "void main() {\n"
+        "  gl_Position = a_position;\n"
+        "}";
+
+    const char* kFragmentShaderString =
+        "precision mediump float;\n"
+        "uniform vec4 u_colorA;\n"
+        "uniform float u_colorU;\n"
+        "uniform vec4 u_colorC;\n"
+        "void main() {\n"
+        "  gl_FragColor = u_colorA + u_colorC;\n"
+        "}";
+    // clang-format on
+
+    const GLint kColorULocation = 1;
+    const GLint kNonexistingLocation = 5;
+    const GLint kUnboundLocation = 6;
+
+    compileProgram(kVertexShaderString, kFragmentShaderString);
+
+    glBindFragmentInputLocationCHROMIUM(mProgram, kColorULocation, "u_colorU");
+
+    // The non-existing input should behave like existing but optimized away input.
+    glBindFragmentInputLocationCHROMIUM(mProgram, kNonexistingLocation, "nonexisting");
+
+    // Let A and C be assigned automatic locations.
+    ASSERT_TRUE(linkProgram() == true);
+
+    const GLfloat kColor[16] = {};
+
+    // No errors on bound locations, since caller does not know
+    // if the driver optimizes them away or not.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorULocation, GL_CONSTANT_CHROMIUM, 1, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    // No errors on bound locations of names that do not exist
+    // in the shader. Otherwise it would be inconsistent wrt the
+    // optimization case.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kNonexistingLocation, GL_CONSTANT_CHROMIUM, 1, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    // The above are equal to updating -1.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_CONSTANT_CHROMIUM, 1, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    // No errors when updating with other type either.
+    // The type can not be known with the non-existing case.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kColorULocation, GL_CONSTANT_CHROMIUM, 4, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kNonexistingLocation, GL_CONSTANT_CHROMIUM, 4, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, -1, GL_CONSTANT_CHROMIUM, 4, kColor);
+    ASSERT_GL_NO_ERROR();
+
+    // Updating an unbound, non-existing location still causes an error.
+    glProgramPathFragmentInputGenCHROMIUM(mProgram, kUnboundLocation, GL_CONSTANT_CHROMIUM, 4, kColor);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
+
+}  // namespace
+
+ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingTest,
+                       ES2_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGL(),
+                       ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingDrawTest,
+                       ES2_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGL(),
+                       ES3_OPENGLES());
+
+ANGLE_INSTANTIATE_TEST(CHROMIUMPathRenderingWithTexturingTest,
+                       ES2_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGL(),
+                       ES3_OPENGLES());
\ No newline at end of file