diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp
new file mode 100644
index 0000000..672e07e
--- /dev/null
+++ b/gm/constcolorprocessor.cpp
@@ -0,0 +1,197 @@
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This test only works with the GPU backend.
+
+#include "gm.h"
+
+#if SK_SUPPORT_GPU
+
+#include "GrContext.h"
+#include "GrTest.h"
+#include "effects/GrConstColorProcessor.h"
+#include "SkGr.h"
+#include "SkGradientShader.h"
+
+namespace skiagm {
+/**
+ * This GM directly exercises GrConstColorProcessor.
+ */
+class ConstColorProcessor : public GM {
+public:
+    ConstColorProcessor() {
+        this->setBGColor(0xFFDDDDDD);
+    }
+
+protected:
+    SkString onShortName() override {
+        return SkString("const_color_processor");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(kWidth, kHeight);
+    }
+
+    void onOnceBeforeDraw() override {
+        SkColor colors[] = { 0xFFFF0000, 0x2000FF00, 0xFF0000FF};
+        SkPoint pts[] = { SkPoint::Make(0, 0), SkPoint::Make(kRectSize, kRectSize) };
+        fShader.reset(SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY_COUNT(colors),
+                       SkShader::kClamp_TileMode));
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
+        if (NULL == rt) {
+            return;
+        }
+        GrContext* context = rt->getContext();
+        if (NULL == context) {
+            this->drawGpuOnlyMessage(canvas);
+            return;
+        }
+
+        static const GrColor kColors[] = {
+            0xFFFFFFFF,
+            0xFFFF00FF,
+            0x80000000,
+            0x00000000,
+        };
+
+        static const SkColor kPaintColors[] = {
+            0xFFFFFFFF,
+            0xFFFF0000,
+            0x80FF0000,
+            0x00000000,
+        };
+
+        static const char* kModeStrs[] {
+            "kIgnore",
+            "kModulateRGBA",
+            "kModulateA",
+        };
+        GR_STATIC_ASSERT(SK_ARRAY_COUNT(kModeStrs) == GrConstColorProcessor::kInputModeCnt);
+
+        SkScalar y = kPad;
+        SkScalar x = kPad;
+        SkScalar maxW = 0;
+        for (size_t paintType = 0; paintType < SK_ARRAY_COUNT(kPaintColors) + 1; ++paintType) {
+            for (size_t procColor = 0; procColor < SK_ARRAY_COUNT(kColors); ++procColor) {
+                for (int m = 0; m < GrConstColorProcessor::kInputModeCnt; ++m) {
+                    // translate by x,y for the canvas draws and the test target draws.
+                    canvas->save();
+                    canvas->translate(x, y);
+                    const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y);
+
+                    // rect to draw
+                    SkRect renderRect = SkRect::MakeXYWH(0, 0, kRectSize, kRectSize);
+
+                    GrTestTarget tt;
+                    context->getTestTarget(&tt);
+                    if (NULL == tt.target()) {
+                        SkDEBUGFAIL("Couldn't get Gr test target.");
+                        return;
+                    }
+
+                    GrPaint grPaint;
+                    SkPaint skPaint;
+                    if (paintType >= SK_ARRAY_COUNT(kPaintColors)) {
+                        skPaint.setShader(fShader);
+                    } else {
+                        skPaint.setColor(kPaintColors[paintType]);
+                    }
+                    SkPaint2GrPaintShader(context, rt, skPaint, viewMatrix, false, &grPaint);
+
+                    GrConstColorProcessor::InputMode mode = (GrConstColorProcessor::InputMode) m;
+                    GrColor color = kColors[procColor];
+                    SkAutoTUnref<GrFragmentProcessor> fp(GrConstColorProcessor::Create(color, mode));
+
+                    GrPipelineBuilder pipelineBuilder;
+                    GrClip clip;
+                    pipelineBuilder.setFromPaint(grPaint, rt, clip);
+                    pipelineBuilder.addColorProcessor(fp);
+
+                    tt.target()->drawSimpleRect(&pipelineBuilder,
+                                                grPaint.getColor(),
+                                                viewMatrix,
+                                                renderRect);
+
+                    // Draw labels for the input to the processor and the processor to the right of
+                    // the test rect. The input label appears above the processor label.
+                    SkPaint labelPaint;
+                    labelPaint.setAntiAlias(true);
+                    labelPaint.setTextSize(10.f);
+                    SkString inputLabel;
+                    inputLabel.set("Input: ");
+                    if (paintType >= SK_ARRAY_COUNT(kPaintColors)) {
+                        inputLabel.append("gradient");
+                    } else {
+                        inputLabel.appendf("0x%08x", kPaintColors[paintType]);
+                    }
+                    SkString procLabel;
+                    procLabel.printf("Proc: [0x%08x, %s]", kColors[procColor], kModeStrs[m]);
+
+                    SkRect inputLabelBounds;
+                    // get the bounds of the text in order to position it
+                    labelPaint.measureText(inputLabel.c_str(), inputLabel.size(),
+                                           &inputLabelBounds);
+                    canvas->drawText(inputLabel.c_str(), inputLabel.size(),
+                                     renderRect.fRight + kPad,
+                                     -inputLabelBounds.fTop, labelPaint);
+                    // update the bounds to reflect the offset we used to draw it.
+                    inputLabelBounds.offset(renderRect.fRight + kPad, -inputLabelBounds.fTop);
+
+                    SkRect procLabelBounds;
+                    labelPaint.measureText(procLabel.c_str(), procLabel.size(),
+                                           &procLabelBounds);
+                    canvas->drawText(procLabel.c_str(), procLabel.size(),
+                                     renderRect.fRight + kPad,
+                                     inputLabelBounds.fBottom + 2.f - procLabelBounds.fTop,
+                                     labelPaint);
+                    procLabelBounds.offset(renderRect.fRight + kPad,
+                                           inputLabelBounds.fBottom + 2.f - procLabelBounds.fTop);
+
+                    labelPaint.setStrokeWidth(0);
+                    labelPaint.setStyle(SkPaint::kStroke_Style);
+                    canvas->drawRect(renderRect, labelPaint);
+
+                    canvas->restore();
+
+                    // update x and y for the next test case.
+                    SkScalar height = renderRect.height();
+                    SkScalar width = SkTMax(inputLabelBounds.fRight, procLabelBounds.fRight);
+                    maxW = SkTMax(maxW, width);
+                    y += height + kPad;
+                    if (y + height > kHeight) {
+                        y = kPad;
+                        x += maxW + kPad;
+                        maxW = 0;
+                    }
+                }
+            }
+        }
+    }
+
+private:
+    // Use this as a way of generating and input FP
+    SkAutoTUnref<SkShader>      fShader;
+
+    static const SkScalar       kPad;
+    static const SkScalar       kRectSize;
+    static const int            kWidth  = 820;
+    static const int            kHeight = 500;
+
+    typedef GM INHERITED;
+};
+
+const SkScalar ConstColorProcessor::kPad = 10.f;
+const SkScalar ConstColorProcessor::kRectSize = 20.f;
+
+DEF_GM( return SkNEW(ConstColorProcessor); )
+}
+
+#endif
diff --git a/gyp/gmslides.gypi b/gyp/gmslides.gypi
index 8effe7f..c575194 100644
--- a/gyp/gmslides.gypi
+++ b/gyp/gmslides.gypi
@@ -65,6 +65,7 @@
         '../gm/complexclip3.cpp',
         '../gm/composeshader.cpp',
         '../gm/conicpaths.cpp',
+        '../gm/constcolorprocessor.cpp',
         '../gm/convexpaths.cpp',
         '../gm/convexpolyclip.cpp',
         '../gm/convexpolyeffect.cpp',
diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi
index 8d2dcbd..a2c227a 100644
--- a/gyp/gpu.gypi
+++ b/gyp/gpu.gypi
@@ -38,6 +38,7 @@
       '<(skia_include_path)/gpu/GrUserConfig.h',
       '<(skia_include_path)/gpu/GrXferProcessor.h',
 
+      '<(skia_include_path)/gpu/effects/GrConstColorProcessor.h',
       '<(skia_include_path)/gpu/effects/GrCoverageSetOpXP.h',
       '<(skia_include_path)/gpu/effects/GrCustomXfermode.h',
       '<(skia_include_path)/gpu/effects/GrPorterDuffXferProcessor.h',
@@ -204,6 +205,7 @@
       '<(skia_src_path)/gpu/effects/Gr1DKernelEffect.h',
       '<(skia_src_path)/gpu/effects/GrConfigConversionEffect.cpp',
       '<(skia_src_path)/gpu/effects/GrConfigConversionEffect.h',
+      '<(skia_src_path)/gpu/effects/GrConstColorProcessor.cpp',
       '<(skia_src_path)/gpu/effects/GrCoverageSetOpXP.cpp',
       '<(skia_src_path)/gpu/effects/GrCustomXfermode.cpp',
       '<(skia_src_path)/gpu/effects/GrCustomXfermodePriv.h',
diff --git a/include/gpu/GrInvariantOutput.h b/include/gpu/GrInvariantOutput.h
index 4977333..fd0a7f8 100644
--- a/include/gpu/GrInvariantOutput.h
+++ b/include/gpu/GrInvariantOutput.h
@@ -79,6 +79,7 @@
     };
 
     void mulByUnknownOpaqueFourComponents() {
+        SkDEBUGCODE(this->validate());
         if (this->isOpaque()) {
             fValidFlags = kA_GrColorComponentFlag;
             fIsSingleComponent = false;
@@ -87,26 +88,32 @@
             // multiplied is opaque.
             this->mulByUnknownFourComponents();
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownFourComponents() {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             this->internalSetToUnknown();
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByUnknownSingleComponent() {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha()) {
             this->internalSetToTransparentBlack();
         } else {
             // We don't need to change fIsSingleComponent in this case
             fValidFlags = 0;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void mulByKnownSingleComponent(uint8_t alpha) {
+        SkDEBUGCODE(this->validate());
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
@@ -116,20 +123,89 @@
                                          SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
+                // We don't need to change fIsSingleComponent in this case
             }
         }
+        SkDEBUGCODE(this->validate());
+    }
+
+    void mulByKnownFourComponents(GrColor color) {
+        SkDEBUGCODE(this->validate());
+        uint32_t a;
+        if (GetAlphaAndCheckSingleChannel(color, &a)) {
+            this->mulByKnownSingleComponent(a);
+        } else {
+            if (color != 0xffffffff) {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
+                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
+                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
+                    SkMulDiv255Round(GrColorUnpackA(fColor), a));
+                if (kRGBA_GrColorComponentFlags == fValidFlags) {
+                    fIsSingleComponent = GetAlphaAndCheckSingleChannel(fColor, &a);
+                }
+            }
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by color.
+    void mulAlphaByKnownFourComponents(GrColor color) {
+        SkDEBUGCODE(this->validate());
+        uint32_t a;
+        if (GetAlphaAndCheckSingleChannel(color, &a)) {
+            this->mulAlphaByKnownSingleComponent(a);
+        } else if (fValidFlags & kA_GrColorComponentFlag) {
+            GrColor preAlpha = GrColorUnpackA(fColor);
+            if (0 == preAlpha) {
+                this->internalSetToTransparentBlack();
+            } else {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(preAlpha, GrColorUnpackR(color)),
+                    SkMulDiv255Round(preAlpha, GrColorUnpackG(color)),
+                    SkMulDiv255Round(preAlpha, GrColorUnpackB(color)),
+                    SkMulDiv255Round(preAlpha, a));
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            }
+        } else {
+            fValidFlags = 0;
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by the alpha param and sets all channels
+    // equal to that value.
+    void mulAlphaByKnownSingleComponent(uint8_t alpha) {
+        SkDEBUGCODE(this->validate());
+        if (0 == alpha || this->hasZeroAlpha()) {
+            this->internalSetToTransparentBlack();
+        } else {
+            if (fValidFlags & kA_GrColorComponentFlag) {
+                GrColor a = GrColorUnpackA(fColor);
+                a = SkMulDiv255Round(alpha, a);
+                fColor = GrColorPackRGBA(a, a, a, a);
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            } else {
+                fValidFlags = 0;
+            }
+            fIsSingleComponent = true;
+        }
+        SkDEBUGCODE(this->validate());
     }
 
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         fValidFlags = validFlags;
         fColor = color;
         fIsSingleComponent = false;
@@ -137,14 +213,28 @@
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        if (kRGBA_GrColorComponentFlags == fValidFlags) {
+            uint32_t a;
+            if (GetAlphaAndCheckSingleChannel(color, &a)) {
+                fIsSingleComponent = true;
+            }
+        } else if (kA_GrColorComponentFlag & fValidFlags) {
+            // Assuming fColor is premul means if a is 0 the color must be all 0s.
+            if (!GrColorUnpackA(fColor)) {
+                this->internalSetToTransparentBlack();
+            }
+        }
+        SkDEBUGCODE(this->validate());
     }
 
     void setToUnknown(ReadInput readsInput) {
+        SkDEBUGCODE(this->validate());
         this->internalSetToUnknown();
         fNonMulStageFound= true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        SkDEBUGCODE(this->validate());
     }
 
     // Temporary setter to handle LCD text correctly until we improve texture pixel config queries
@@ -165,6 +255,13 @@
 private:
     friend class GrProcOptInfo;
 
+    /** Extracts the alpha channel and returns true if r,g,b == a. */
+    static bool GetAlphaAndCheckSingleChannel(GrColor color, uint32_t* alpha) {
+        *alpha = GrColorUnpackA(color);
+        return *alpha == GrColorUnpackR(color) && *alpha == GrColorUnpackG(color) &&
+               *alpha == GrColorUnpackB(color);
+    }
+
     void reset(GrColor color, GrColorComponentFlags flags, bool isSingleComponent) {
         fColor = color;
         fValidFlags = flags;
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 7cb614d..026b256 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -78,8 +78,9 @@
 // Sets the color of GrPaint to the value of the parameter paintColor
 // Callers may subsequently modify the GrPaint. Setting constantColor indicates
 // that the final paint will draw the same color at every pixel. This allows
-// an optimization where the the color filter can be applied to the SkPaint's
-// color once while converting to GrPaint and then ignored.
+// an optimization where the color filter can be applied to the SkPaint's
+// color once while converting to GrPaint and then ignored. TODO: Remove this
+// bool and use the invariant info to automatically apply the color filter.
 void SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget*, const SkPaint& skPaint,
                              GrColor paintColor, bool constantColor, GrPaint* grPaint);
 
diff --git a/include/gpu/effects/GrConstColorProcessor.h b/include/gpu/effects/GrConstColorProcessor.h
new file mode 100644
index 0000000..27ee0df
--- /dev/null
+++ b/include/gpu/effects/GrConstColorProcessor.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrColorProcessor_DEFINED
+#define GrColorProcessor_DEFINED
+
+#include "GrFragmentProcessor.h"
+
+class GrInvariantOutput;
+
+/**
+ * This is a simple GrFragmentProcessor that outputs a constant color. It may do one of the
+ * following with its input color: ignore it, or multiply it by the constant color, multiply its
+ * alpha by the constant color and ignore the input color's r, g, and b.
+ */
+class GrConstColorProcessor : public GrFragmentProcessor {
+public:
+    enum InputMode {
+        kIgnore_InputMode,
+        kModulateRGBA_InputMode,
+        kModulateA_InputMode,
+
+        kLastInputMode = kModulateA_InputMode
+    };
+    static const int kInputModeCnt = kLastInputMode + 1;
+
+    static GrFragmentProcessor* Create(GrColor color, InputMode mode) {
+        return SkNEW_ARGS(GrConstColorProcessor, (color, mode));
+    }
+
+    ~GrConstColorProcessor() override {}
+
+    const char* name() const override { return "Color"; }
+
+    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
+
+    GrGLFragmentProcessor* createGLInstance() const override;
+
+    GrColor color() const { return fColor; }
+
+    InputMode inputMode() const { return fMode; }
+
+private:
+    GrConstColorProcessor(GrColor color, InputMode mode) : fColor(color), fMode(mode) {
+        this->initClassID<GrConstColorProcessor>();
+    }
+
+    bool onIsEqual(const GrFragmentProcessor&) const override;
+
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
+
+    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
+
+    GrColor     fColor;
+    InputMode   fMode;
+
+    typedef GrFragmentProcessor INHERITED;
+};
+
+#endif
diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp
index 4bda2e1..1457bed 100644
--- a/src/gpu/GrProcessor.cpp
+++ b/src/gpu/GrProcessor.cpp
@@ -49,7 +49,7 @@
  * we verify the count is as expected.  If a new factory is added, then these numbers must be
  * manually adjusted.
  */
-static const int kFPFactoryCount = 37;
+static const int kFPFactoryCount = 38;
 static const int kGPFactoryCount = 14;
 static const int kXPFactoryCount = 5;
 
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
new file mode 100644
index 0000000..5f28694
--- /dev/null
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "effects/GrConstColorProcessor.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/GrGLSL.h"
+#include "gl/builders/GrGLProgramBuilder.h"
+
+class GLConstColorProcessor : public GrGLFragmentProcessor {
+public:
+    GLConstColorProcessor() : fPrevColor(GrColor_ILLEGAL) {}
+
+    void emitCode(GrGLFPBuilder* builder,
+                  const GrFragmentProcessor& fp,
+                  const char* outputColor,
+                  const char* inputColor,
+                  const TransformedCoordsArray& coords,
+                  const TextureSamplerArray& samplers) override {
+        GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+        const char* colorUni;
+        fColorUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                            kVec4f_GrSLType, kMedium_GrSLPrecision, "constantColor",
+                                            &colorUni);
+        switch (fp.cast<GrConstColorProcessor>().inputMode()) {
+            case GrConstColorProcessor::kIgnore_InputMode:
+                fsBuilder->codeAppendf("%s = %s;", outputColor, colorUni);
+                break;
+            case GrConstColorProcessor::kModulateRGBA_InputMode:
+                fsBuilder->codeAppendf("%s = %s * %s;", outputColor, inputColor, colorUni);
+                break;
+            case GrConstColorProcessor::kModulateA_InputMode:
+                fsBuilder->codeAppendf("%s = %s.a * %s;", outputColor, inputColor, colorUni);
+                break;
+        }
+    }
+
+    void setData(const GrGLProgramDataManager& pdm, const GrProcessor& processor) override {
+        GrColor color = processor.cast<GrConstColorProcessor>().color();
+        // We use the "illegal" color value as an uninit sentinel. However, ut isn't inherently
+        // illegal to use this processor with unpremul colors. So we correctly handle the case
+        // when the "illegal" color is used but we will always upload it.
+        if (GrColor_ILLEGAL == color || fPrevColor != color) {
+            static const GrGLfloat scale = 1.f / 255.f;
+            GrGLfloat floatColor[4] = {
+                GrColorUnpackR(color) * scale,
+                GrColorUnpackG(color) * scale,
+                GrColorUnpackB(color) * scale,
+                GrColorUnpackA(color) * scale,
+            };
+            pdm.set4fv(fColorUniform, 1, floatColor);
+            fPrevColor = color;
+        }
+    }
+
+private:
+    GrGLProgramDataManager::UniformHandle fColorUniform;
+    GrColor                               fPrevColor;
+
+    typedef GrGLFragmentProcessor INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrConstColorProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
+    if (kIgnore_InputMode == fMode) {
+        inout->setToOther(kRGBA_GrColorComponentFlags, fColor, GrInvariantOutput::kWill_ReadInput);
+    } else {
+        GrColor r = GrColorUnpackR(fColor);
+        bool colorIsSingleChannel = r == GrColorUnpackG(fColor) && r == GrColorUnpackB(fColor) &&
+                                    r == GrColorUnpackA(fColor);
+        if (kModulateRGBA_InputMode == fMode) {
+            if (colorIsSingleChannel) {
+                inout->mulByKnownSingleComponent(r);
+            } else {
+                inout->mulByKnownFourComponents(fColor);
+            }
+        } else {
+            if (colorIsSingleChannel) {
+                inout->mulAlphaByKnownSingleComponent(r);
+            } else {
+                inout->mulAlphaByKnownFourComponents(fColor);
+            }
+        }
+    }
+}
+
+void GrConstColorProcessor::getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder* b) const {
+    b->add32(fMode);
+}
+
+GrGLFragmentProcessor* GrConstColorProcessor::createGLInstance() const  {
+    return SkNEW(GLConstColorProcessor);
+}
+
+bool GrConstColorProcessor::onIsEqual(const GrFragmentProcessor& other) const {
+    const GrConstColorProcessor& that = other.cast<GrConstColorProcessor>();
+    return fMode == that.fMode && fColor == that.fColor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConstColorProcessor);
+
+GrFragmentProcessor* GrConstColorProcessor::TestCreate(SkRandom* random,
+                                                       GrContext*,
+                                                       const GrDrawTargetCaps&,
+                                                       GrTexture*[]) {
+    GrColor color;
+    int colorPicker = random->nextULessThan(3);
+    switch (colorPicker) {
+        case 0: {
+            uint32_t a = random->nextULessThan(0x100);
+            uint32_t r = random->nextULessThan(a+1);
+            uint32_t g = random->nextULessThan(a+1);
+            uint32_t b = random->nextULessThan(a+1);
+            color = GrColorPackRGBA(r, g, b, a);
+            break;
+        }
+        case 1:
+            color = 0;
+            break;
+        case 2:
+            color = random->nextULessThan(0x100);
+            color = color | (color << 8) | (color << 16) | (color << 24);
+            break;
+    }
+    InputMode mode = static_cast<InputMode>(random->nextULessThan(kInputModeCnt));
+    return GrConstColorProcessor::Create(color, mode);
+}