GrFP can express distance vector field req., program builder declares variable for it

src/core/SkNormalBevelSource.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkNormalBevelSource.h"
 
 #include "SkNormalSource.h"
+#include "SkNormalSourcePriv.h"
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
 #if SK_SUPPORT_GPU
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGr.h"
 
 class NormalBevelFP : public GrFragmentProcessor {
 public:
     NormalBevelFP(SkNormalSource::BevelType type, SkScalar width, SkScalar height)
         : fType(type)
         , fWidth(width)
         , fHeight(height) {
         this->initClassID<NormalBevelFP>();
+
+        fUsesDistanceVectorField = true;
     }
 
-    class GLSLNormalBevelFP : public GrGLSLFragmentProcessor {
+    class GLSLNormalBevelFP : public GLSLNormalFP {
     public:
         GLSLNormalBevelFP() {
             fPrevWidth = SkFloatToScalar(0.0f);
             fPrevHeight = SkFloatToScalar(0.0f);
         }
 
-        void emitCode(EmitArgs& args) override {
-            GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+        void onEmitCode(EmitArgs& args) override {
+            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             const char* widthUniName = nullptr;
             fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
                     kDefault_GrSLPrecision, "Width", &widthUniName);
 
             const char* heightUniName = nullptr;
             fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
                     kDefault_GrSLPrecision, "Height", &heightUniName);
 
-            fragBuilder->codeAppendf("%s = vec4(0, 0, 1, 0);", args.fOutputColor);
+            fragBuilder->codeAppendf("%s = vec4(0.0, 0.0, 1.0, 0.0);", args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const NormalBevelFP& fp = proc.cast<NormalBevelFP>();
             b->add32(static_cast<int>(fp.fType));
         }
 
     protected:
-        void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+        void setNormalData(const GrGLSLProgramDataManager& pdman,
+                           const GrProcessor& proc) override {
             const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
 
             if (fPrevWidth  != normalBevelFP.fWidth) {
                 pdman.set1f(fWidthUni, normalBevelFP.fWidth);
                 fPrevWidth = normalBevelFP.fWidth;
             }
             if (fPrevHeight != normalBevelFP.fHeight) {
                 pdman.set1f(fHeightUni, normalBevelFP.fHeight);
                 fPrevHeight = normalBevelFP.fHeight;
             }
@@ skipping 86 matching lines @@
 sk_sp<SkNormalSource> SkNormalSource::MakeBevel(BevelType type, SkScalar width, SkScalar height) {
     /* TODO make sure this checks are tolerant enough to account for loss of conversion when GPUs
        use 16-bit float types. We don't want to assume stuff is non-zero on the GPU and be wrong.*/
     SkASSERT(width > 0.0f && !SkScalarNearlyZero(width));
     if (SkScalarNearlyZero(height)) {
         return SkNormalSource::MakeFlat();
     }
 
     return sk_make_sp<SkNormalBevelSourceImpl>(type, width, height);
 }