diff --git a/gn/gpu.gni b/gn/gpu.gni
index 6276597..5c1335a 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -400,6 +400,18 @@
   "$_src/gpu/effects/GrYUVtoRGBEffect.cpp",
   "$_src/gpu/effects/GrYUVtoRGBEffect.h",
 
+  # gradients
+  "$_src/gpu/gradients/GrSingleIntervalGradientColorizer.cpp",
+  "$_src/gpu/gradients/GrSingleIntervalGradientColorizer.h",
+  "$_src/gpu/gradients/GrLinearGradientLayout.cpp",
+  "$_src/gpu/gradients/GrLinearGradientLayout.h",
+  "$_src/gpu/gradients/GrClampedGradientEffect.cpp",
+  "$_src/gpu/gradients/GrClampedGradientEffect.h",
+  "$_src/gpu/gradients/GrTiledGradientEffect.cpp",
+  "$_src/gpu/gradients/GrTiledGradientEffect.h",
+  "$_src/gpu/gradients/GrGradientShader.cpp",
+  "$_src/gpu/gradients/GrGradientShader.h",
+
   # text
   "$_src/gpu/text/GrAtlasManager.cpp",
   "$_src/gpu/text/GrAtlasManager.h",
diff --git a/gn/sksl.gni b/gn/sksl.gni
index ced7745..ad34e22 100644
--- a/gn/sksl.gni
+++ b/gn/sksl.gni
@@ -46,4 +46,8 @@
   "$_src/gpu/effects/GrSimpleTextureEffect.fp",
   "$_src/gpu/effects/GrUnpremulInputFragmentProcessor.fp",
   "$_src/gpu/effects/GrYUVtoRGBEffect.fp",
+  "$_src/gpu/gradients/GrSingleIntervalGradientColorizer.fp",
+  "$_src/gpu/gradients/GrLinearGradientLayout.fp",
+  "$_src/gpu/gradients/GrClampedGradientEffect.fp",
+  "$_src/gpu/gradients/GrTiledGradientEffect.fp",
 ]
diff --git a/public.bzl b/public.bzl
index 82502b4..b3cbe99 100644
--- a/public.bzl
+++ b/public.bzl
@@ -418,6 +418,7 @@
     "src/ports",
     "src/sfnt",
     "src/shaders",
+    "src/shaders/gradients",
     "src/sksl",
     "src/utils",
     "third_party/gif",
diff --git a/src/gpu/GrProcessor.h b/src/gpu/GrProcessor.h
index de42bc9..9eba390 100644
--- a/src/gpu/GrProcessor.h
+++ b/src/gpu/GrProcessor.h
@@ -95,6 +95,7 @@
         kGrCCPathProcessor_ClassID,
         kGrCircleBlurFragmentProcessor_ClassID,
         kGrCircleEffect_ClassID,
+        kGrClampedGradientEffect_ClassID,
         kGrColorSpaceXformEffect_ClassID,
         kGrConfigConversionEffect_ClassID,
         kGrConicEffect_ClassID,
@@ -113,6 +114,7 @@
         kGrImprovedPerlinNoiseEffect_ClassID,
         kGrLightingEffect_ClassID,
         kGrLinearGradient_ClassID,
+        kGrLinearGradientLayout_ClassID,
         kGrLumaColorFilterEffect_ClassID,
         kGrMagnifierEffect_ClassID,
         kGrMatrixConvolutionEffect_ClassID,
@@ -129,11 +131,13 @@
         kGrRRectBlurEffect_ClassID,
         kGrRRectShadowGeoProc_ClassID,
         kGrSimpleTextureEffect_ClassID,
+        kGrSingleIntervalGradientColorizer_ClassID,
         kGrSkSLFP_ClassID,
         kGrSpecularLightingEffect_ClassID,
         kGrSRGBEffect_ClassID,
         kGrSweepGradient_ClassID,
         kGrTextureDomainEffect_ClassID,
+        kGrTiledGradientEffect_ClassID,
         kGrUnpremulInputFragmentProcessor_ClassID,
         kGrYUVtoRGBEffect_ClassID,
         kHighContrastFilterEffect_ClassID,
diff --git a/src/gpu/gradients/GrClampedGradientEffect.cpp b/src/gpu/gradients/GrClampedGradientEffect.cpp
new file mode 100644
index 0000000..4c8b3a1
--- /dev/null
+++ b/src/gpu/gradients/GrClampedGradientEffect.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrClampedGradientEffect.fp; do not modify.
+ **************************************************************************************************/
+#include "GrClampedGradientEffect.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramBuilder.h"
+#include "GrTexture.h"
+#include "SkSLCPP.h"
+#include "SkSLUtil.h"
+class GrGLSLClampedGradientEffect : public GrGLSLFragmentProcessor {
+public:
+    GrGLSLClampedGradientEffect() {}
+    void emitCode(EmitArgs& args) override {
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrClampedGradientEffect& _outer = args.fFp.cast<GrClampedGradientEffect>();
+        (void)_outer;
+        auto leftBorderColor = _outer.leftBorderColor();
+        (void)leftBorderColor;
+        auto rightBorderColor = _outer.rightBorderColor();
+        (void)rightBorderColor;
+        fLeftBorderColorVar = args.fUniformHandler->addUniform(
+                kFragment_GrShaderFlag, kHalf4_GrSLType, kDefault_GrSLPrecision, "leftBorderColor");
+        fRightBorderColorVar =
+                args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+                                                 kDefault_GrSLPrecision, "rightBorderColor");
+        SkString _child1("_child1");
+        this->emitChild(1, &_child1, args);
+        fragBuilder->codeAppendf(
+                "half4 t = %s;\nif (t.x < 0.0) {\n    %s = %s;\n} else if (float(t.x) > 1.0) {\n   "
+                " %s = %s;\n} else {",
+                _child1.c_str(), args.fOutputColor,
+                args.fUniformHandler->getUniformCStr(fLeftBorderColorVar), args.fOutputColor,
+                args.fUniformHandler->getUniformCStr(fRightBorderColorVar));
+        SkString _input0("t");
+        SkString _child0("_child0");
+        this->emitChild(0, _input0.c_str(), &_child0, args);
+        fragBuilder->codeAppendf("\n    %s = %s;\n}\n", args.fOutputColor, _child0.c_str());
+    }
+
+private:
+    void onSetData(const GrGLSLProgramDataManager& pdman,
+                   const GrFragmentProcessor& _proc) override {
+        const GrClampedGradientEffect& _outer = _proc.cast<GrClampedGradientEffect>();
+        {
+            const GrColor4f& leftBorderColorValue = _outer.leftBorderColor();
+            if (fLeftBorderColorPrev != leftBorderColorValue) {
+                fLeftBorderColorPrev = leftBorderColorValue;
+                pdman.set4fv(fLeftBorderColorVar, 1, leftBorderColorValue.fRGBA);
+            }
+            const GrColor4f& rightBorderColorValue = _outer.rightBorderColor();
+            if (fRightBorderColorPrev != rightBorderColorValue) {
+                fRightBorderColorPrev = rightBorderColorValue;
+                pdman.set4fv(fRightBorderColorVar, 1, rightBorderColorValue.fRGBA);
+            }
+        }
+    }
+    GrColor4f fLeftBorderColorPrev = GrColor4f::kIllegalConstructor;
+    GrColor4f fRightBorderColorPrev = GrColor4f::kIllegalConstructor;
+    UniformHandle fLeftBorderColorVar;
+    UniformHandle fRightBorderColorVar;
+};
+GrGLSLFragmentProcessor* GrClampedGradientEffect::onCreateGLSLInstance() const {
+    return new GrGLSLClampedGradientEffect();
+}
+void GrClampedGradientEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
+                                                    GrProcessorKeyBuilder* b) const {}
+bool GrClampedGradientEffect::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrClampedGradientEffect& that = other.cast<GrClampedGradientEffect>();
+    (void)that;
+    if (fLeftBorderColor != that.fLeftBorderColor) return false;
+    if (fRightBorderColor != that.fRightBorderColor) return false;
+    return true;
+}
+GrClampedGradientEffect::GrClampedGradientEffect(const GrClampedGradientEffect& src)
+        : INHERITED(kGrClampedGradientEffect_ClassID, src.optimizationFlags())
+        , fLeftBorderColor(src.fLeftBorderColor)
+        , fRightBorderColor(src.fRightBorderColor) {
+    this->registerChildProcessor(src.childProcessor(0).clone());
+    this->registerChildProcessor(src.childProcessor(1).clone());
+}
+std::unique_ptr<GrFragmentProcessor> GrClampedGradientEffect::clone() const {
+    return std::unique_ptr<GrFragmentProcessor>(new GrClampedGradientEffect(*this));
+}
diff --git a/src/gpu/gradients/GrClampedGradientEffect.fp b/src/gpu/gradients/GrClampedGradientEffect.fp
new file mode 100644
index 0000000..d8b97aa
--- /dev/null
+++ b/src/gpu/gradients/GrClampedGradientEffect.fp
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This master effect implements clamping on the layout coordinate and requires specifying the
+// border colors that are used when outside the clamped boundary. Gradients with the
+// SkShader::kClamp_TileMode should use the colors at their first and last stop (after adding dummy
+// stops for t=0,t=1) as the border color. This will automatically replicate the edge color, even if
+// when there is a hard stop.
+//
+// The SkShader::kDecal_TileMode can be produced by specifying transparent black as the border
+// colors, regardless of the gradient's stop colors.
+
+in fragmentProcessor colorizer;
+in fragmentProcessor gradLayout;
+
+layout(ctype=GrColor4f, tracked) in uniform half4 leftBorderColor;  // t < 0.0
+layout(ctype=GrColor4f, tracked) in uniform half4 rightBorderColor; // t > 1.0
+
+void main() {
+    half4 t = process(gradLayout);
+
+    // If t.x is below 0, use the left border color without invoking the child processor. If any t.x
+    // is above 1, use the right border color. Otherwise, t is in the [0, 1] range assumed by the
+    // colorizer FP, so delegate to the child processor.
+    if (t.x < 0) {
+        sk_OutColor = leftBorderColor;
+    } else if (t.x > 1.0) {
+        sk_OutColor = rightBorderColor;
+    } else {
+        sk_OutColor = process(colorizer, t);
+    }
+}
diff --git a/src/gpu/gradients/GrClampedGradientEffect.h b/src/gpu/gradients/GrClampedGradientEffect.h
new file mode 100644
index 0000000..af3e11d
--- /dev/null
+++ b/src/gpu/gradients/GrClampedGradientEffect.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrClampedGradientEffect.fp; do not modify.
+ **************************************************************************************************/
+#ifndef GrClampedGradientEffect_DEFINED
+#define GrClampedGradientEffect_DEFINED
+#include "SkTypes.h"
+#include "GrFragmentProcessor.h"
+#include "GrCoordTransform.h"
+class GrClampedGradientEffect : public GrFragmentProcessor {
+public:
+    const GrColor4f& leftBorderColor() const { return fLeftBorderColor; }
+    const GrColor4f& rightBorderColor() const { return fRightBorderColor; }
+    static std::unique_ptr<GrFragmentProcessor> Make(
+            std::unique_ptr<GrFragmentProcessor> colorizer,
+            std::unique_ptr<GrFragmentProcessor> gradLayout, GrColor4f leftBorderColor,
+            GrColor4f rightBorderColor) {
+        return std::unique_ptr<GrFragmentProcessor>(new GrClampedGradientEffect(
+                std::move(colorizer), std::move(gradLayout), leftBorderColor, rightBorderColor));
+    }
+    GrClampedGradientEffect(const GrClampedGradientEffect& src);
+    std::unique_ptr<GrFragmentProcessor> clone() const override;
+    const char* name() const override { return "ClampedGradientEffect"; }
+
+private:
+    GrClampedGradientEffect(std::unique_ptr<GrFragmentProcessor> colorizer,
+                            std::unique_ptr<GrFragmentProcessor> gradLayout,
+                            GrColor4f leftBorderColor, GrColor4f rightBorderColor)
+            : INHERITED(kGrClampedGradientEffect_ClassID, kNone_OptimizationFlags)
+            , fLeftBorderColor(leftBorderColor)
+            , fRightBorderColor(rightBorderColor) {
+        this->registerChildProcessor(std::move(colorizer));
+        this->registerChildProcessor(std::move(gradLayout));
+    }
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
+    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST
+    GrColor4f fLeftBorderColor;
+    GrColor4f fRightBorderColor;
+    typedef GrFragmentProcessor INHERITED;
+};
+#endif
diff --git a/src/gpu/gradients/GrGradientShader.cpp b/src/gpu/gradients/GrGradientShader.cpp
new file mode 100644
index 0000000..83397a0
--- /dev/null
+++ b/src/gpu/gradients/GrGradientShader.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrGradientShader.h"
+
+#include "GrClampedGradientEffect.h"
+#include "GrTiledGradientEffect.h"
+
+#include "GrLinearGradientLayout.h"
+#include "GrSingleIntervalGradientColorizer.h"
+
+#include "SkGradientShaderPriv.h"
+#include "GrColor.h"
+
+// Analyze the shader's color stops and positions and chooses an appropriate colorizer to represent
+// the gradient.
+static std::unique_ptr<GrFragmentProcessor> make_colorizer(const SkGradientShaderBase& shader,
+        const GrFPArgs& args, const GrColor4f* colors) {
+    // If there are hard stops at the beginning or end, the first and/or last color should be
+    // ignored by the colorizer since it should only be used in a clamped border color. By detecting
+    // and removing these stops at the beginning, it makes optimizing the remaining color stops
+    // simpler.
+
+    // SkGradientShaderBase guarantees that fOrigPos[0] == 0 by adding a dummy
+    bool bottomHardStop = shader.fOrigPos && SkScalarNearlyEqual(shader.fOrigPos[0],
+                                                                 shader.fOrigPos[1]);
+    // The same is true for fOrigPos[end] == 1
+    bool topHardStop = shader.fOrigPos &&
+            SkScalarNearlyEqual(shader.fOrigPos[shader.fColorCount - 2],
+                                shader.fOrigPos[shader.fColorCount - 1]);
+
+    int offset = 0;
+    int count = shader.fColorCount;
+    if (bottomHardStop) {
+        offset += 1;
+        count--;
+    }
+    if (topHardStop) {
+        count--;
+    }
+
+    // Currently only supports 2-color single intervals. However, when the gradient has hard stops
+    // and is clamped, certain 3 or 4 color gradients are equivalent to a two color interval
+    if (count == 2) {
+        return GrSingleIntervalGradientColorizer::Make(colors[offset], colors[offset + 1]);
+    }
+
+    return nullptr;
+}
+
+// Combines the colorizer and layout with an appropriately configured master effect based on the
+// gradient's tile mode
+static std::unique_ptr<GrFragmentProcessor> make_gradient(const SkGradientShaderBase& shader,
+        const GrFPArgs& args, std::unique_ptr<GrFragmentProcessor> layout) {
+    // No shader is possible if a layout couldn't be created, e.g. a layout-specific Make() returned
+    // null.
+    if (layout == nullptr) {
+        return nullptr;
+    }
+
+    // Convert all colors into destination space and into GrColor4fs, and handle
+    // premul issues depending on the interpolation mode
+    bool inputPremul = shader.getGradFlags() & SkGradientShader::kInterpolateColorsInPremul_Flag;
+    SkAutoSTMalloc<4, GrColor4f> colors(shader.fColorCount);
+    SkColor4fXformer xformedColors(shader.fOrigColors4f, shader.fColorCount,
+            shader.fColorSpace.get(), args.fDstColorSpaceInfo->colorSpace());
+    for (int i = 0; i < shader.fColorCount; i++) {
+        colors[i] = GrColor4f::FromSkColor4f(xformedColors.fColors[i]);
+        if (inputPremul) {
+            colors[i] = colors[i].premul();
+        }
+    }
+
+    // All gradients are colorized the same way, regardless of layout
+    std::unique_ptr<GrFragmentProcessor> colorizer = make_colorizer(shader, args, colors.get());
+    if (colorizer == nullptr) {
+        return nullptr;
+    }
+
+    // All tile modes are supported (unless something was added to SkShader)
+    std::unique_ptr<GrFragmentProcessor> master;
+    switch(shader.getTileMode()) {
+        case SkShader::kRepeat_TileMode:
+            master = GrTiledGradientEffect::Make(std::move(colorizer), std::move(layout),
+                                                 /* mirror */ false);
+            break;
+        case SkShader::kMirror_TileMode:
+            master = GrTiledGradientEffect::Make(std::move(colorizer), std::move(layout),
+                                                 /* mirror */ true);
+            break;
+        case SkShader::kClamp_TileMode:
+            // For the clamped mode, the border colors are the first and last colors, corresponding
+            // to t=0 and t=1, because SkGradientShaderBase enforces that by adding color stops as
+            // appropriate. If there is a hard stop, this grabs the expected outer colors for the
+            // border.
+            master = GrClampedGradientEffect::Make(std::move(colorizer), std::move(layout),
+                                                   colors[0], colors[shader.fColorCount - 1]);
+            break;
+        case SkShader::kDecal_TileMode:
+            master = GrClampedGradientEffect::Make(std::move(colorizer), std::move(layout),
+                                                   GrColor4f::TransparentBlack(),
+                                                   GrColor4f::TransparentBlack());
+            break;
+    }
+
+    if (master == nullptr) {
+        // Unexpected tile mode
+        return nullptr;
+    }
+
+    if (!inputPremul) {
+        // When interpolating unpremul colors, the output of the gradient
+        // effect fp's will also be unpremul, so wrap it to ensure its premul.
+        // - this is unnecessary when interpolating premul colors since the
+        //   output color is premul by nature
+        master = GrFragmentProcessor::PremulOutput(std::move(master));
+    }
+
+    return GrFragmentProcessor::MulChildByInputAlpha(std::move(master));
+}
+
+namespace GrGradientShader {
+
+std::unique_ptr<GrFragmentProcessor> MakeLinear(const SkLinearGradient& shader,
+                                                const GrFPArgs& args) {
+    return make_gradient(shader, args, GrLinearGradientLayout::Make(shader, args));
+}
+
+}
diff --git a/src/gpu/gradients/GrGradientShader.h b/src/gpu/gradients/GrGradientShader.h
new file mode 100644
index 0000000..a781b02
--- /dev/null
+++ b/src/gpu/gradients/GrGradientShader.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGradientShader_DEFINE
+#define GrGradientShader_DEFINE
+
+#include "GrFPArgs.h"
+#include "SkGradientShaderPriv.h"
+#include "SkLinearGradient.h"
+
+namespace GrGradientShader {
+    std::unique_ptr<GrFragmentProcessor> MakeLinear(const SkLinearGradient& shader,
+                                                    const GrFPArgs& args);
+}
+
+#endif // GrGradientShader_DEFINE
diff --git a/src/gpu/gradients/GrLinearGradientLayout.cpp b/src/gpu/gradients/GrLinearGradientLayout.cpp
new file mode 100644
index 0000000..0a32093
--- /dev/null
+++ b/src/gpu/gradients/GrLinearGradientLayout.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrLinearGradientLayout.fp; do not modify.
+ **************************************************************************************************/
+#include "GrLinearGradientLayout.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramBuilder.h"
+#include "GrTexture.h"
+#include "SkSLCPP.h"
+#include "SkSLUtil.h"
+class GrGLSLLinearGradientLayout : public GrGLSLFragmentProcessor {
+public:
+    GrGLSLLinearGradientLayout() {}
+    void emitCode(EmitArgs& args) override {
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrLinearGradientLayout& _outer = args.fFp.cast<GrLinearGradientLayout>();
+        (void)_outer;
+        auto gradientMatrix = _outer.gradientMatrix();
+        (void)gradientMatrix;
+        SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
+        fragBuilder->codeAppendf("%s = half4(half(%s.x));\n", args.fOutputColor,
+                                 sk_TransformedCoords2D_0.c_str());
+    }
+
+private:
+    void onSetData(const GrGLSLProgramDataManager& pdman,
+                   const GrFragmentProcessor& _proc) override {}
+};
+GrGLSLFragmentProcessor* GrLinearGradientLayout::onCreateGLSLInstance() const {
+    return new GrGLSLLinearGradientLayout();
+}
+void GrLinearGradientLayout::onGetGLSLProcessorKey(const GrShaderCaps& caps,
+                                                   GrProcessorKeyBuilder* b) const {}
+bool GrLinearGradientLayout::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrLinearGradientLayout& that = other.cast<GrLinearGradientLayout>();
+    (void)that;
+    if (fGradientMatrix != that.fGradientMatrix) return false;
+    return true;
+}
+GrLinearGradientLayout::GrLinearGradientLayout(const GrLinearGradientLayout& src)
+        : INHERITED(kGrLinearGradientLayout_ClassID, src.optimizationFlags())
+        , fGradientMatrix(src.fGradientMatrix)
+        , fCoordTransform0(src.fCoordTransform0) {
+    this->addCoordTransform(&fCoordTransform0);
+}
+std::unique_ptr<GrFragmentProcessor> GrLinearGradientLayout::clone() const {
+    return std::unique_ptr<GrFragmentProcessor>(new GrLinearGradientLayout(*this));
+}
+
+std::unique_ptr<GrFragmentProcessor> GrLinearGradientLayout::Make(const SkLinearGradient& grad,
+                                                                  const GrFPArgs& args) {
+    SkMatrix matrix;
+    if (!grad.totalLocalMatrix(args.fPreLocalMatrix, args.fPostLocalMatrix)->invert(&matrix)) {
+        return nullptr;
+    }
+    matrix.postConcat(grad.getGradientMatrix());
+    return std::unique_ptr<GrFragmentProcessor>(new GrLinearGradientLayout(matrix));
+}
diff --git a/src/gpu/gradients/GrLinearGradientLayout.fp b/src/gpu/gradients/GrLinearGradientLayout.fp
new file mode 100644
index 0000000..7e2829c
--- /dev/null
+++ b/src/gpu/gradients/GrLinearGradientLayout.fp
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+in half4x4 gradientMatrix;
+
+@coordTransform {
+    gradientMatrix
+}
+
+void main() {
+    sk_OutColor = half4(sk_TransformedCoords2D[0].x);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+@header {
+    #include "SkLinearGradient.h"
+}
+
+@make {
+    static std::unique_ptr<GrFragmentProcessor> Make(const SkLinearGradient& gradient,
+                                                     const GrFPArgs& args);
+}
+
+@cppEnd {
+    std::unique_ptr<GrFragmentProcessor> GrLinearGradientLayout::Make(
+            const SkLinearGradient& grad, const GrFPArgs& args) {
+        SkMatrix matrix;
+        if (!grad.totalLocalMatrix(args.fPreLocalMatrix, args.fPostLocalMatrix)->invert(&matrix)) {
+            return nullptr;
+        }
+        matrix.postConcat(grad.getGradientMatrix());
+        return std::unique_ptr<GrFragmentProcessor>(new GrLinearGradientLayout(matrix));
+    }
+}
diff --git a/src/gpu/gradients/GrLinearGradientLayout.h b/src/gpu/gradients/GrLinearGradientLayout.h
new file mode 100644
index 0000000..19c9d8c
--- /dev/null
+++ b/src/gpu/gradients/GrLinearGradientLayout.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrLinearGradientLayout.fp; do not modify.
+ **************************************************************************************************/
+#ifndef GrLinearGradientLayout_DEFINED
+#define GrLinearGradientLayout_DEFINED
+#include "SkTypes.h"
+
+#include "SkLinearGradient.h"
+#include "GrFragmentProcessor.h"
+#include "GrCoordTransform.h"
+class GrLinearGradientLayout : public GrFragmentProcessor {
+public:
+    const SkMatrix44& gradientMatrix() const { return fGradientMatrix; }
+
+    static std::unique_ptr<GrFragmentProcessor> Make(const SkLinearGradient& gradient,
+                                                     const GrFPArgs& args);
+    GrLinearGradientLayout(const GrLinearGradientLayout& src);
+    std::unique_ptr<GrFragmentProcessor> clone() const override;
+    const char* name() const override { return "LinearGradientLayout"; }
+
+private:
+    GrLinearGradientLayout(SkMatrix44 gradientMatrix)
+            : INHERITED(kGrLinearGradientLayout_ClassID, kNone_OptimizationFlags)
+            , fGradientMatrix(gradientMatrix)
+            , fCoordTransform0(gradientMatrix) {
+        this->addCoordTransform(&fCoordTransform0);
+    }
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
+    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST
+    SkMatrix44 fGradientMatrix;
+    GrCoordTransform fCoordTransform0;
+    typedef GrFragmentProcessor INHERITED;
+};
+#endif
diff --git a/src/gpu/gradients/GrSingleIntervalGradientColorizer.cpp b/src/gpu/gradients/GrSingleIntervalGradientColorizer.cpp
new file mode 100644
index 0000000..d54f94f
--- /dev/null
+++ b/src/gpu/gradients/GrSingleIntervalGradientColorizer.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrSingleIntervalGradientColorizer.fp; do not modify.
+ **************************************************************************************************/
+#include "GrSingleIntervalGradientColorizer.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramBuilder.h"
+#include "GrTexture.h"
+#include "SkSLCPP.h"
+#include "SkSLUtil.h"
+class GrGLSLSingleIntervalGradientColorizer : public GrGLSLFragmentProcessor {
+public:
+    GrGLSLSingleIntervalGradientColorizer() {}
+    void emitCode(EmitArgs& args) override {
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrSingleIntervalGradientColorizer& _outer =
+                args.fFp.cast<GrSingleIntervalGradientColorizer>();
+        (void)_outer;
+        auto start = _outer.start();
+        (void)start;
+        auto end = _outer.end();
+        (void)end;
+        fStartVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+                                                     kDefault_GrSLPrecision, "start");
+        fEndVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+                                                   kDefault_GrSLPrecision, "end");
+        fragBuilder->codeAppendf("half t = %s.x;\n%s = (1.0 - t) * %s + t * %s;\n",
+                                 args.fInputColor, args.fOutputColor,
+                                 args.fUniformHandler->getUniformCStr(fStartVar),
+                                 args.fUniformHandler->getUniformCStr(fEndVar));
+    }
+
+private:
+    void onSetData(const GrGLSLProgramDataManager& pdman,
+                   const GrFragmentProcessor& _proc) override {
+        const GrSingleIntervalGradientColorizer& _outer =
+                _proc.cast<GrSingleIntervalGradientColorizer>();
+        {
+            const GrColor4f& startValue = _outer.start();
+            if (fStartPrev != startValue) {
+                fStartPrev = startValue;
+                pdman.set4fv(fStartVar, 1, startValue.fRGBA);
+            }
+            const GrColor4f& endValue = _outer.end();
+            if (fEndPrev != endValue) {
+                fEndPrev = endValue;
+                pdman.set4fv(fEndVar, 1, endValue.fRGBA);
+            }
+        }
+    }
+    GrColor4f fStartPrev = GrColor4f::kIllegalConstructor;
+    GrColor4f fEndPrev = GrColor4f::kIllegalConstructor;
+    UniformHandle fStartVar;
+    UniformHandle fEndVar;
+};
+GrGLSLFragmentProcessor* GrSingleIntervalGradientColorizer::onCreateGLSLInstance() const {
+    return new GrGLSLSingleIntervalGradientColorizer();
+}
+void GrSingleIntervalGradientColorizer::onGetGLSLProcessorKey(const GrShaderCaps& caps,
+                                                              GrProcessorKeyBuilder* b) const {}
+bool GrSingleIntervalGradientColorizer::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrSingleIntervalGradientColorizer& that = other.cast<GrSingleIntervalGradientColorizer>();
+    (void)that;
+    if (fStart != that.fStart) return false;
+    if (fEnd != that.fEnd) return false;
+    return true;
+}
+GrSingleIntervalGradientColorizer::GrSingleIntervalGradientColorizer(
+        const GrSingleIntervalGradientColorizer& src)
+        : INHERITED(kGrSingleIntervalGradientColorizer_ClassID, src.optimizationFlags())
+        , fStart(src.fStart)
+        , fEnd(src.fEnd) {}
+std::unique_ptr<GrFragmentProcessor> GrSingleIntervalGradientColorizer::clone() const {
+    return std::unique_ptr<GrFragmentProcessor>(new GrSingleIntervalGradientColorizer(*this));
+}
diff --git a/src/gpu/gradients/GrSingleIntervalGradientColorizer.fp b/src/gpu/gradients/GrSingleIntervalGradientColorizer.fp
new file mode 100644
index 0000000..8be9082
--- /dev/null
+++ b/src/gpu/gradients/GrSingleIntervalGradientColorizer.fp
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This only supports a 2-color single interval so it is a simple  linear interpolation between the
+// two end points based on t. But it serves as a good test for connecting all of the plumbing into a
+// functional gradient shader.
+
+layout(ctype=GrColor4f, tracked) in uniform half4 start;
+layout(ctype=GrColor4f, tracked) in uniform half4 end;
+
+void main() {
+    half t = sk_InColor.x;
+
+    // Clamping and/or wrapping was already handled by the parent shader so the output color is a
+    // simple lerp.
+    sk_OutColor = (1 - t) * start + t * end;
+}
diff --git a/src/gpu/gradients/GrSingleIntervalGradientColorizer.h b/src/gpu/gradients/GrSingleIntervalGradientColorizer.h
new file mode 100644
index 0000000..f5e5e34
--- /dev/null
+++ b/src/gpu/gradients/GrSingleIntervalGradientColorizer.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrSingleIntervalGradientColorizer.fp; do not modify.
+ **************************************************************************************************/
+#ifndef GrSingleIntervalGradientColorizer_DEFINED
+#define GrSingleIntervalGradientColorizer_DEFINED
+#include "SkTypes.h"
+#include "GrFragmentProcessor.h"
+#include "GrCoordTransform.h"
+class GrSingleIntervalGradientColorizer : public GrFragmentProcessor {
+public:
+    const GrColor4f& start() const { return fStart; }
+    const GrColor4f& end() const { return fEnd; }
+    static std::unique_ptr<GrFragmentProcessor> Make(GrColor4f start, GrColor4f end) {
+        return std::unique_ptr<GrFragmentProcessor>(
+                new GrSingleIntervalGradientColorizer(start, end));
+    }
+    GrSingleIntervalGradientColorizer(const GrSingleIntervalGradientColorizer& src);
+    std::unique_ptr<GrFragmentProcessor> clone() const override;
+    const char* name() const override { return "SingleIntervalGradientColorizer"; }
+
+private:
+    GrSingleIntervalGradientColorizer(GrColor4f start, GrColor4f end)
+            : INHERITED(kGrSingleIntervalGradientColorizer_ClassID, kNone_OptimizationFlags)
+            , fStart(start)
+            , fEnd(end) {}
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
+    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST
+    GrColor4f fStart;
+    GrColor4f fEnd;
+    typedef GrFragmentProcessor INHERITED;
+};
+#endif
diff --git a/src/gpu/gradients/GrTiledGradientEffect.cpp b/src/gpu/gradients/GrTiledGradientEffect.cpp
new file mode 100644
index 0000000..2bc4e74
--- /dev/null
+++ b/src/gpu/gradients/GrTiledGradientEffect.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrTiledGradientEffect.fp; do not modify.
+ **************************************************************************************************/
+#include "GrTiledGradientEffect.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramBuilder.h"
+#include "GrTexture.h"
+#include "SkSLCPP.h"
+#include "SkSLUtil.h"
+class GrGLSLTiledGradientEffect : public GrGLSLFragmentProcessor {
+public:
+    GrGLSLTiledGradientEffect() {}
+    void emitCode(EmitArgs& args) override {
+        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+        const GrTiledGradientEffect& _outer = args.fFp.cast<GrTiledGradientEffect>();
+        (void)_outer;
+        auto mirror = _outer.mirror();
+        (void)mirror;
+        SkString _child1("_child1");
+        this->emitChild(1, &_child1, args);
+        fragBuilder->codeAppendf(
+                "half4 t = %s;\n@if (%s) {\n    half t_1 = t.x - 1.0;\n    half tiled_t = "
+                "(float(t_1) - 2.0 * floor(float(float(t_1) * 0.5))) - 1.0;\n    if "
+                "(sk_Caps.mustDoOpBetweenFloorAndAbs) {\n        tiled_t = "
+                "half(clamp(float(tiled_t), -1.0, 1.0));\n    }\n    t.x = "
+                "half(abs(float(tiled_t)));\n} else {\n    t.x = half(fract(float(t.x)));\n}",
+                _child1.c_str(), (_outer.mirror() ? "true" : "false"));
+        SkString _input0("t");
+        SkString _child0("_child0");
+        this->emitChild(0, _input0.c_str(), &_child0, args);
+        fragBuilder->codeAppendf("\n%s = %s;\n", args.fOutputColor, _child0.c_str());
+    }
+
+private:
+    void onSetData(const GrGLSLProgramDataManager& pdman,
+                   const GrFragmentProcessor& _proc) override {}
+};
+GrGLSLFragmentProcessor* GrTiledGradientEffect::onCreateGLSLInstance() const {
+    return new GrGLSLTiledGradientEffect();
+}
+void GrTiledGradientEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
+                                                  GrProcessorKeyBuilder* b) const {
+    b->add32((int32_t)fMirror);
+}
+bool GrTiledGradientEffect::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrTiledGradientEffect& that = other.cast<GrTiledGradientEffect>();
+    (void)that;
+    if (fMirror != that.fMirror) return false;
+    return true;
+}
+GrTiledGradientEffect::GrTiledGradientEffect(const GrTiledGradientEffect& src)
+        : INHERITED(kGrTiledGradientEffect_ClassID, src.optimizationFlags()), fMirror(src.fMirror) {
+    this->registerChildProcessor(src.childProcessor(0).clone());
+    this->registerChildProcessor(src.childProcessor(1).clone());
+}
+std::unique_ptr<GrFragmentProcessor> GrTiledGradientEffect::clone() const {
+    return std::unique_ptr<GrFragmentProcessor>(new GrTiledGradientEffect(*this));
+}
diff --git a/src/gpu/gradients/GrTiledGradientEffect.fp b/src/gpu/gradients/GrTiledGradientEffect.fp
new file mode 100644
index 0000000..9ba6cf1
--- /dev/null
+++ b/src/gpu/gradients/GrTiledGradientEffect.fp
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Provides tiling for the repeat or mirror modes.
+
+in fragmentProcessor colorizer;
+in fragmentProcessor gradLayout;
+
+layout(key) in bool mirror;
+
+void main() {
+    half4 t = process(gradLayout);
+
+    @if(mirror) {
+        half t_1 = t.x - 1;
+        half tiled_t = t_1 - 2 * floor(t_1 * 0.5) - 1;
+        if (sk_Caps.mustDoOpBetweenFloorAndAbs) {
+            // At this point the expected value of tiled_t should between -1 and 1, so this clamp
+            // has no effect other than to break up the floor and abs calls and make sure the
+            // compiler doesn't merge them back together.
+            tiled_t = clamp(tiled_t, -1, 1);
+        }
+        t.x = abs(tiled_t);
+    } else {
+        // Simple repeat mode
+        t.x = fract(t.x);
+    }
+
+    // t.x has been tiled (repeat or mirrored), but pass through remaining 3 components unmodified.
+    sk_OutColor = process(colorizer, t);
+}
diff --git a/src/gpu/gradients/GrTiledGradientEffect.h b/src/gpu/gradients/GrTiledGradientEffect.h
new file mode 100644
index 0000000..8216742
--- /dev/null
+++ b/src/gpu/gradients/GrTiledGradientEffect.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**************************************************************************************************
+ *** This file was autogenerated from GrTiledGradientEffect.fp; do not modify.
+ **************************************************************************************************/
+#ifndef GrTiledGradientEffect_DEFINED
+#define GrTiledGradientEffect_DEFINED
+#include "SkTypes.h"
+#include "GrFragmentProcessor.h"
+#include "GrCoordTransform.h"
+class GrTiledGradientEffect : public GrFragmentProcessor {
+public:
+    bool mirror() const { return fMirror; }
+    static std::unique_ptr<GrFragmentProcessor> Make(
+            std::unique_ptr<GrFragmentProcessor> colorizer,
+            std::unique_ptr<GrFragmentProcessor> gradLayout, bool mirror) {
+        return std::unique_ptr<GrFragmentProcessor>(
+                new GrTiledGradientEffect(std::move(colorizer), std::move(gradLayout), mirror));
+    }
+    GrTiledGradientEffect(const GrTiledGradientEffect& src);
+    std::unique_ptr<GrFragmentProcessor> clone() const override;
+    const char* name() const override { return "TiledGradientEffect"; }
+
+private:
+    GrTiledGradientEffect(std::unique_ptr<GrFragmentProcessor> colorizer,
+                          std::unique_ptr<GrFragmentProcessor> gradLayout, bool mirror)
+            : INHERITED(kGrTiledGradientEffect_ClassID, kNone_OptimizationFlags), fMirror(mirror) {
+        this->registerChildProcessor(std::move(colorizer));
+        this->registerChildProcessor(std::move(gradLayout));
+    }
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
+    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST
+    bool fMirror;
+    typedef GrFragmentProcessor INHERITED;
+};
+#endif
diff --git a/src/gpu/gradients/README.md b/src/gpu/gradients/README.md
new file mode 100644
index 0000000..22b8452
--- /dev/null
+++ b/src/gpu/gradients/README.md
@@ -0,0 +1,35 @@
+Gradients on the GPU
+====================
+
+Gradients can be thought of, at a very high level, as three pieces:
+
+1. A color interpolator that is one dimensional, returning a color for an input
+   within the range [0.0, 1.0]. This obfuscates the the definition of specific
+   color stops and how to wrap, tile, or clamp out of bound inputs. A color
+   interpolator will be named GrYGradientColorizer
+2. A layout that converts from 2D geometry/position to the one dimensional
+   domain of the color interpolator. This is how a linear or radial gradient
+   distinguishes itself. When designing a new gradient, this is the component
+   that you have to implement. A layout will generally be named
+   GrXGradientLayout
+3. A master effect that composes the layout and color interpolator together. It
+   is also responsible for implementing the clamping behavior that can be
+   abstracted away from both the layout and colorization.
+
+
+GrClampedGradientEffect handles clamped and decal tile modes, while
+GrTiledGradientEffect implements repeat and mirror tile modes. The GrClampedGradientEffect requires border colors to be specified outside of its colorizer child, but these border colors may be defined by the gradient color stops. Both of these master effects delegate calculating a t interpolant to a child process, perform their respective tile mode operations, and possibly convert the tiled t value (guaranteed to be within 0 and 1) into an output color using their child colorizer process.
+
+Because of how child processors are currently defined, where they have a single
+half4 input and a single half4 output, their is a type mismatch between the 1D
+t value and the 4D inputs/outputs of the layout and colorizer processes. For
+now, the master effect assumes an untiled t is output in sk_OutColor.x by the
+layout and it tiles solely off of that value. Any value in y, z, or w are
+passed into the colorizer unmodified. The colorizer should assume that the
+valid tiled t value is in sk_InColor.x and can safely ignore y, z, and w.
+
+Currently there are color interpolators (colorizers) for analytic color cases
+(evaluated directly on the GPU) and sampling a generated texture map.
+
+GrGradientShader provides static factory functions to create
+GrFragmentProcessor graphs that reproduce a particular SkGradientShader.
diff --git a/src/shaders/gradients/SkGradientShaderPriv.h b/src/shaders/gradients/SkGradientShaderPriv.h
index 2c7a5e4..bd31190 100644
--- a/src/shaders/gradients/SkGradientShaderPriv.h
+++ b/src/shaders/gradients/SkGradientShaderPriv.h
@@ -68,6 +68,8 @@
 
     uint32_t getGradFlags() const { return fGradFlags; }
 
+    const SkMatrix& getGradientMatrix() const { return fPtsToUnit; }
+
 protected:
     class GradientShaderBase4fContext;
 
diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp
index 9ad768b..57ad3c5 100644
--- a/src/shaders/gradients/SkLinearGradient.cpp
+++ b/src/shaders/gradients/SkLinearGradient.cpp
@@ -99,6 +99,8 @@
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGr.h"
 
+#include "gradients/GrGradientShader.h"
+
 /////////////////////////////////////////////////////////////////////
 
 class GrLinearGradient : public GrGradientEffect {
@@ -194,6 +196,12 @@
         const GrFPArgs& args) const {
     SkASSERT(args.fContext);
 
+    // Try to use new gradient system first
+    std::unique_ptr<GrFragmentProcessor> gradient = GrGradientShader::MakeLinear(*this, args);
+    if (gradient) {
+        return gradient;
+    }
+
     SkMatrix matrix;
     if (!this->totalLocalMatrix(args.fPreLocalMatrix, args.fPostLocalMatrix)->invert(&matrix)) {
         return nullptr;
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient.h b/src/shaders/gradients/SkTwoPointConicalGradient.h
index b965e15..e126054 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient.h
+++ b/src/shaders/gradients/SkTwoPointConicalGradient.h
@@ -62,7 +62,6 @@
     SkScalar getEndRadius() const { return fRadius2; }
 
     Type getType() const { return fType; }
-    const SkMatrix& getGradientMatrix() const { return fPtsToUnit; }
     const FocalData& getFocalData() const { return fFocalData; }
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTwoPointConicalGradient)
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index f39777e..f1c9ed6 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -135,6 +135,7 @@
     CAP(mustEnableAdvBlendEqs);
     CAP(mustEnableSpecificAdvBlendEqs);
     CAP(mustDeclareFragmentShaderOutput);
+    CAP(mustDoOpBetweenFloorAndAbs);
     CAP(canUseAnyFunctionInShader);
     CAP(floatIs32Bits);
     CAP(integerSupport);
diff --git a/src/sksl/SkSLUtil.h b/src/sksl/SkSLUtil.h
index 3efb539..1654562 100644
--- a/src/sksl/SkSLUtil.h
+++ b/src/sksl/SkSLUtil.h
@@ -109,6 +109,10 @@
         return true;
     }
 
+    bool mustDoOpBetweenFloorAndAbs() const {
+        return false;
+    }
+
     bool mustEnableAdvBlendEqs() const {
         return false;
     }