Implement support for CHROMIUM_path_rendering pseudo extension

Implement support for path rendering in Chromium through
CHROMIUM_path_rendering pseudo extension.

The extension defines a new pseudo-gl function,
BindFragmentInputLocation. This behaves similarly to the
BindUniformLocation pseudo-gl function. The idea is to assign fragment
input location to a fragment input before linking the program.

BUG=chromium:344330

Review URL: https://codereview.chromium.org/1192663002

include/gpu/gl/GrGLFunctions.h

@@ -257,6 +257,8 @@ typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilThenCoverFillPathInstancedProc
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLStencilThenCoverStrokePathInstancedProc)(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues);
 // NV_path_rendering v1.3
 typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLProgramPathFragmentInputGenProc)(GrGLuint program, GrGLint location, GrGLenum genMode, GrGLint components,const GrGLfloat *coeffs);
+// CHROMIUM_path_rendering
+typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GrGLBindFragmentInputLocationProc)(GrGLuint program, GrGLint location, const GrGLchar* name);
 
 /* ARB_program_interface_query */
 typedef GrGLint (GR_GL_FUNCTION_TYPE* GrGLGetProgramResourceLocationProc)(GrGLuint program, GrGLenum programInterface, const GrGLchar *name);

include/gpu/gl/GrGLInterface.h

@@ -350,6 +350,8 @@ public:
         GLPtr<GrGLStencilThenCoverStrokePathInstancedProc> fStencilThenCoverStrokePathInstanced;
         // NV_path_rendering v1.3
         GLPtr<GrGLProgramPathFragmentInputGenProc> fProgramPathFragmentInputGen;
+        // CHROMIUM_path_rendering
+        GLPtr<GrGLBindFragmentInputLocationProc> fBindFragmentInputLocation;
 
         /* NV_framebuffer_mixed_samples */
         GLPtr<GrGLCoverageModulationProc> fCoverageModulation;

src/gpu/gl/GrGLCaps.cpp

@@ -464,16 +464,20 @@ void GrGLCaps::init(const GrContextOptions& contextOptions,
 }
 
 bool GrGLCaps::hasPathRenderingSupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
-    if (!ctxInfo.hasExtension("GL_NV_path_rendering")) {
+    bool hasChromiumPathRendering = ctxInfo.hasExtension("GL_CHROMIUM_path_rendering");
+
+    if (!(ctxInfo.hasExtension("GL_NV_path_rendering") || hasChromiumPathRendering)) {
         return false;
     }
+
     if (kGL_GrGLStandard == ctxInfo.standard()) {
         if (ctxInfo.version() < GR_GL_VER(4, 3) &&
             !ctxInfo.hasExtension("GL_ARB_program_interface_query")) {
             return false;
         }
     } else {
-        if (ctxInfo.version() < GR_GL_VER(3, 1)) {
+        if (!hasChromiumPathRendering &&
+            ctxInfo.version() < GR_GL_VER(3, 1)) {
             return false;
         }
     }

src/gpu/gl/GrGLInterface.cpp

@@ -59,6 +59,7 @@ const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface* interface) {
     newInterface->fFunctions.fStencilThenCoverFillPathInstanced = NULL;
     newInterface->fFunctions.fStencilThenCoverStrokePathInstanced = NULL;
     newInterface->fFunctions.fProgramPathFragmentInputGen = NULL;
+    newInterface->fFunctions.fBindFragmentInputLocation = NULL;
     return newInterface;
 }
 
@@ -483,7 +484,7 @@ bool GrGLInterface::validate() const {
 #endif
     }
 
-    if (fExtensions.has("GL_NV_path_rendering")) {
+    if (fExtensions.has("GL_NV_path_rendering") || fExtensions.has("GL_CHROMIUM_path_rendering")) {
         if (NULL == fFunctions.fMatrixLoadf ||
             NULL == fFunctions.fMatrixLoadIdentity ||
             NULL == fFunctions.fPathCommands ||
@@ -515,6 +516,11 @@ bool GrGLInterface::validate() const {
             ) {
             RETURN_FALSE_INTERFACE
         }
+        if (fExtensions.has("GL_CHROMIUM_path_rendering")) {
+            if (NULL == fFunctions.fBindFragmentInputLocation) {
+                RETURN_FALSE_INTERFACE
+            }
+        }
     }
 
     if (fExtensions.has("GL_EXT_raster_multisample")) {

src/gpu/gl/GrGLPathRendering.cpp

@@ -61,6 +61,9 @@ static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu) {
+    const GrGLInterface* glInterface = gpu->glInterface();
+    fCaps.bindFragmentInputSupport =
+        NULL != glInterface->fFunctions.fBindFragmentInputLocation;
 }
 
 GrGLPathRendering::~GrGLPathRendering() {

src/gpu/gl/GrGLPathRendering.h

@@ -46,6 +46,10 @@ public:
      */
     void abandonGpuResources();
 
+    bool shouldBindFragmentInputs() const {
+        return fCaps.bindFragmentInputSupport;
+    }
+
     // Functions for "separable shader" texturing support.
     void setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
                                               GrGLenum genMode, GrGLint components,
@@ -65,6 +69,13 @@ protected:
     void onDrawPaths(const DrawPathArgs&, const GrPathRange*, const void* indices, PathIndexType,
                      const float transformValues[], PathTransformType, int count) override;
 private:
+    /**
+     * Mark certain functionality as not supported.
+     */
+    struct Caps {
+        bool bindFragmentInputSupport : 1;
+    };
+
     void flushPathStencilSettings(const GrStencilSettings&);
 
     struct MatrixState {
@@ -103,6 +114,7 @@ private:
     SkAutoTDelete<GrGLNameAllocator> fPathNameAllocator;
     MatrixState fHWProjectionMatrixState;
     GrStencilSettings fHWPathStencilSettings;
+    Caps fCaps;
 };
 
 #endif

src/gpu/gl/builders/GrGLPathProgramBuilder.cpp

@@ -35,9 +35,25 @@ GrGLProgramBuilder::SeparableVaryingHandle GrGLPathProgramBuilder::addSeparableV
     return SeparableVaryingHandle::CreateFromSeparableVaryingIndex(varyingInfo.fLocation);
 }
 
+void GrGLPathProgramBuilder::bindProgramResourceLocations(GrGLuint programID) {
+    this->INHERITED::bindProgramResourceLocations(programID);
+    if (!fGpu->glPathRendering()->shouldBindFragmentInputs()) {
+        return;
+    }
+    int count = fSeparableVaryingInfos.count();
+    for (int i = 0; i < count; ++i) {
+        GL_CALL(BindFragmentInputLocation(programID,
+                                          i,
+                                          fSeparableVaryingInfos[i].fVariable.c_str()));
+        fSeparableVaryingInfos[i].fLocation = i;
+    }
+}
+
 void GrGLPathProgramBuilder::resolveProgramResourceLocations(GrGLuint programID) {
     this->INHERITED::resolveProgramResourceLocations(programID);
-
+    if (fGpu->glPathRendering()->shouldBindFragmentInputs()) {
+        return;
+    }
     int count = fSeparableVaryingInfos.count();
     for (int i = 0; i < count; ++i) {
         GrGLint location;

src/gpu/gl/builders/GrGLPathProgramBuilder.h

@@ -17,6 +17,7 @@ public:
 
     SeparableVaryingHandle addSeparableVarying(const char* name, GrGLVertToFrag* v,
                                                GrSLPrecision fsPrecision) override;
+    void bindProgramResourceLocations(GrGLuint programID) override;
     void resolveProgramResourceLocations(GrGLuint programID) override;
 
 private:

src/gpu/gl/builders/GrGLProgramBuilder.h

@@ -328,7 +328,7 @@ protected:
                       GrGLInstalledProc<Proc>*);
 
     GrGLProgram* finalize();
-    void bindProgramResourceLocations(GrGLuint programID);
+    virtual void bindProgramResourceLocations(GrGLuint programID);
     bool checkLinkStatus(GrGLuint programID);
     virtual void resolveProgramResourceLocations(GrGLuint programID);
     void cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs);