re-re-land of skslc now automatically turns on derivatives support

src/sksl/SkSLGLSLCodeGenerator.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #ifndef SKSL_GLSLCODEGENERATOR
 #define SKSL_GLSLCODEGENERATOR
 
@@ skipping 27 matching lines @@
 #include "ir/SkSLVarDeclarations.h"
 #include "ir/SkSLVarDeclarationsStatement.h"
 #include "ir/SkSLVariableReference.h"
 #include "ir/SkSLWhileStatement.h"
 
 namespace SkSL {
 
 #define kLast_Capability SpvCapabilityMultiViewport
 
 struct GLCaps {
-    int fVersion;
+    GLCaps() {}
+
+    int fVersion = 400;
     enum {
         kGL_Standard,
         kGLES_Standard
-    } fStandard;
-    bool fIsCoreProfile;
-    bool fUsesPrecisionModifiers;
-    bool fMustDeclareFragmentShaderOutput;
+    } fStandard = kGL_Standard;
+    bool fIsCoreProfile = false;
+    bool fUsesPrecisionModifiers = false;
+    bool fMustDeclareFragmentShaderOutput = false;
+    bool fShaderDerivativeSupport = true;
+    // extension string to enable derivative support, or null if unnecessary
+    std::string fShaderDerivativeExtensionString;
     // The Tegra3 compiler will sometimes never return if we have min(abs(x), y)
-    bool fCanUseMinAndAbsTogether;
+    bool fCanUseMinAndAbsTogether = true;
     // On Intel GPU there is an issue where it misinterprets an atan argument (second argument only,
     // apparently) of the form "-<expr>" as an int, so we rewrite it as "-1.0 * <expr>" to avoid
     // this problem
-    bool fMustForceNegatedAtanParamToFloat;
+    bool fMustForceNegatedAtanParamToFloat = false;
 };
 
 /**
  * Converts a Program into GLSL code.
  */
 class GLSLCodeGenerator : public CodeGenerator {
 public:
     enum Precedence {
         kParentheses_Precedence    =  1,
         kPostfix_Precedence        =  2,
@@ skipping 10 matching lines @@
         kLogicalXor_Precedence     = 13,
         kLogicalOr_Precedence      = 14,
         kTernary_Precedence        = 15,
         kAssignment_Precedence     = 16,
         kSequence_Precedence       = 17,
         kTopLevel_Precedence       = 18
     };
 
     GLSLCodeGenerator(const Context* context, GLCaps caps)
     : fContext(*context)
-    , fCaps(caps)
-    , fOut(nullptr)
-    , fVarCount(0)
-    , fIndentation(0)
-    , fAtLineStart(true) {}
+    , fCaps(caps) {}
 
     void generateCode(const Program& program, std::ostream& out) override;
 
 private:
     void write(const char* s);
 
     void writeLine();
 
     void writeLine(const char* s);
 
@@ skipping 62 matching lines @@
     void writeForStatement(const ForStatement& f);
 
     void writeWhileStatement(const WhileStatement& w);
 
     void writeDoStatement(const DoStatement& d);
 
     void writeReturnStatement(const ReturnStatement& r);
 
     const Context& fContext;
     const GLCaps fCaps;
-    std::ostream* fOut;
+    std::ostream* fOut = nullptr;
+    std::stringstream fHeader;
     std::string fFunctionHeader;
     Program::Kind fProgramKind;
-    int fVarCount;
-    int fIndentation;
-    bool fAtLineStart;
+    int fVarCount = 0;
+    int fIndentation = 0;
+    bool fAtLineStart = false;
     // Keeps track of which struct types we have written. Given that we are unlikely to ever write 
     // more than one or two structs per shader, a simple linear search will be faster than anything 
     // fancier.
     std::vector<const Type*> fWrittenStructs;
+    // true if we have run into usages of dFdx / dFdy
+    bool fFoundDerivatives = false;
 };
 
 }
 
 #endif