diff --git a/src/effects/SkBlendImageFilter.cpp b/src/effects/SkBlendImageFilter.cpp
index f4ef9def7..825767783 100644
--- a/src/effects/SkBlendImageFilter.cpp
+++ b/src/effects/SkBlendImageFilter.cpp
@@ -263,8 +263,8 @@ void GrGLBlendEffect::emitFS(GrGLShaderBuilder* builder,
     const char* bgColor = inputColor;
     const char* fgColor = "fgColor";
     code->appendf("\t\tvec4 %s = ", fgColor);
-    builder->emitTextureLookup(samplerName);
-    code->appendf(";\n");
+    builder->appendTextureLookup(code, samplerName);
+    code->append(";\n");
     code->appendf("\t\t%s.a = 1.0 - (1.0 - %s.a) * (1.0 - %s.b);\n", outputColor, bgColor, fgColor);
     switch (fMode) {
       case SkBlendImageFilter::kNormal_Mode:
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 408e7021f..8eb28bb3c 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -1160,7 +1160,7 @@ void GrGLLightingEffect::emitFS(GrGLShaderBuilder* builder,
             SkString texCoords;
             texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc);
             code->appendf("\t\tm[%d] = ", index++);
-            builder->emitTextureLookup(samplerName, texCoords.c_str());
+            builder->appendTextureLookup(code, samplerName, texCoords.c_str());
             code->appendf(".a;\n");
         }
     }
@@ -1168,11 +1168,12 @@ void GrGLLightingEffect::emitFS(GrGLShaderBuilder* builder,
     SkString arg;
     arg.appendf("%s * m[4]", surfScale);
     fLight->emitSurfaceToLight(builder, code, arg.c_str());
-    code->appendf(";\n");
+    code->append(";\n");
     code->appendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ",
                   outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale);
     fLight->emitLightColor(builder, "surfaceToLight");
-    code->appendf(")%s;\n", builder->fModulate.c_str());
+    code->append(");\n");
+    GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
 }
 
 GrGLProgramStage::StageKey GrGLLightingEffect::GenKey(const GrCustomStage& s,
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 314532181..6b8324a7a 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -159,10 +159,11 @@ void GrGLMagnifierEffect::emitFS(GrGLShaderBuilder* state,
 
     code->appendf("\t\tvec2 mix_coord = mix(coord, zoom_coord, weight);\n");
     code->appendf("\t\tvec4 output_color = ");
-    state->emitTextureLookup(samplerName, "mix_coord");
-    code->appendf(";\n");
+    state->appendTextureLookup(code, samplerName, "mix_coord");
+    code->append(";\n");
 
     code->appendf("\t\t%s = output_color;", outputColor);
+    GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
 }
 
 void GrGLMagnifierEffect::setData(const GrGLUniformManager& uman,
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index eb121a72d..04dc2270c 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -319,11 +319,11 @@ void GrGLMorphologyEffect::emitFS(GrGLShaderBuilder* builder,
     const char* func;
     switch (fType) {
         case GrMorphologyEffect::kErode_MorphologyType:
-            code->appendf("\t\tvec4 value = vec4(1, 1, 1, 1);\n");
+            code->appendf("\t\t%s = vec4(1, 1, 1, 1);\n", outputColor);
             func = "min";
             break;
         case GrMorphologyEffect::kDilate_MorphologyType:
-            code->appendf("\t\tvec4 value = vec4(0, 0, 0, 0);\n");
+            code->appendf("\t\t%s = vec4(0, 0, 0, 0);\n", outputColor);
             func = "max";
             break;
         default:
@@ -336,12 +336,12 @@ void GrGLMorphologyEffect::emitFS(GrGLShaderBuilder* builder,
     code->appendf("\t\tvec2 coord = %s - %d.0 * %s;\n",
                    builder->defaultTexCoordsName(), fRadius, imgInc);
     code->appendf("\t\tfor (int i = 0; i < %d; i++) {\n", this->width());
-    code->appendf("\t\t\tvalue = %s(value, ", func);
-    builder->emitTextureLookup(samplerName, "coord");
+    code->appendf("\t\t\t%s = %s(%s, ", outputColor, func, outputColor);
+    builder->appendTextureLookup(&builder->fFSCode, samplerName, "coord");
     code->appendf(");\n");
     code->appendf("\t\t\tcoord += %s;\n", imgInc);
     code->appendf("\t\t}\n");
-    code->appendf("\t\t%s = value%s;\n", outputColor, builder->fModulate.c_str());
+    GrGLSLMulVarBy4f(code, 2, outputColor, inputColor);
 }
 
 GrGLProgramStage::StageKey GrGLMorphologyEffect::GenKey(const GrCustomStage& s,
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 891b1cdf9..3d989b761 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -699,14 +699,19 @@ void GrGLGradientStage::setData(const GrGLUniformManager& uman,
 }
 
 void GrGLGradientStage::emitColorLookup(GrGLShaderBuilder* builder,
-                                        const char* tName,
+                                        const char* gradientTValue,
                                         const char* outputColor,
+                                        const char* inputColor,
                                         const char* samplerName) {
 
-    builder->fFSCode.appendf("\tvec2 coord = vec2(%s, %s);\n",
-                             tName,
-                             builder->getUniformVariable(fFSYUni).c_str());
-    builder->emitTextureLookupAndModulate(outputColor, samplerName, "coord");
+    SkString* code = &builder->fFSCode;
+    code->appendf("\tvec2 coord = vec2(%s, %s);\n",
+                  gradientTValue,
+                  builder->getUniformVariable(fFSYUni).c_str());
+    GrGLSLMulVarBy4f(code, 1, outputColor, inputColor);
+    code->appendf("\t%s = ", outputColor);
+    builder->appendTextureLookupAndModulate(code, inputColor, samplerName, "coord");
+    code->append(";\n");
 }
 
 /////////////////////////////////////////////////////////////////////
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index 37959678a..2b584f30b 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -287,8 +287,11 @@ public:
 
     // emit code that gets a fragment's color from an expression for t; for now
     // this always uses the texture, but for simpler cases we'll be able to lerp
-    void emitColorLookup(GrGLShaderBuilder* builder, const char* t,
-                         const char* outputColor, const char* samplerName);
+    void emitColorLookup(GrGLShaderBuilder* builder,
+                         const char* gradientTValue,
+                         const char* outputColor,
+                         const char* inputColor,
+                         const char* samplerName);
 
 private:
 
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 78d2f24a0..6415927c7 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -553,7 +553,7 @@ void GrGLLinearGradient::emitFS(GrGLShaderBuilder* builder,
                                 const char* samplerName) {
     SkString t;
     t.printf("%s.x", builder->defaultTexCoordsName());
-    this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
+    this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
 }
 
 /////////////////////////////////////////////////////////////////////
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 317ab68b4..98433e28e 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -553,7 +553,7 @@ void GrGLRadialGradient::emitFS(GrGLShaderBuilder* builder,
                                 const char* samplerName) {
     SkString t;
     t.printf("length(%s.xy)", builder->defaultTexCoordsName());
-    this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
+    this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
 }
 
 /////////////////////////////////////////////////////////////////////
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 15547de6d..22b211871 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -459,7 +459,7 @@ void GrGLSweepGradient::emitFS(GrGLShaderBuilder* builder,
     SkString t;
     t.printf("atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5",
         builder->defaultTexCoordsName(), builder->defaultTexCoordsName());
-    this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
+    this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
 }
 
 /////////////////////////////////////////////////////////////////////
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 8b32ab6bb..c84989b67 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -593,7 +593,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
                       p5.c_str(), p3.c_str());
 
         code->appendf("\t\t");
-        this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
+        this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
 
         // otherwise, if r(t) for the larger root was <= 0, try the other root
         code->appendf("\t\t} else {\n");
@@ -605,7 +605,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
                       tName.c_str(), p5.c_str(), p3.c_str());
 
         code->appendf("\t\t\t");
-        this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
+        this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
 
         // end if (r(t) > 0) for smaller root
         code->appendf("\t\t\t}\n");
@@ -623,7 +623,7 @@ void GrGLConical2Gradient::emitFS(GrGLShaderBuilder* builder,
         code->appendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                       p5.c_str(), p3.c_str());
         code->appendf("\t");
-        this->emitColorLookup(builder, tName.c_str(), outputColor, samplerName);
+        this->emitColorLookup(builder, tName.c_str(), outputColor, inputColor, samplerName);
         code->appendf("\t}\n");
     }
 }
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 693dc32b0..2192707cc 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -601,7 +601,7 @@ void GrGLRadial2Gradient::emitFS(GrGLShaderBuilder* builder,
         t.printf("-%s / %s", cName.c_str(), bVar.c_str());
     }
 
-    this->emitColorLookup(builder, t.c_str(), outputColor, samplerName);
+    this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplerName);
 }
 
 void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index fbf5a4090..318c03e65 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -23,37 +23,39 @@ public:
                         const char* outputColor,
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE {
-        builder->fFSCode.append("\tvec4 tempColor;\n");
-        builder->emitTextureLookupAndModulate("tempColor", samplerName);
+        builder->fFSCode.appendf("\t\t%s = ", outputColor);
+        builder->appendTextureLookup(&builder->fFSCode, samplerName);
+        builder->fFSCode.appendf("%s;\n", builder->fSwizzle.c_str());
         if (GrConfigConversionEffect::kNone_PMConversion == fPMConversion) {
             GrAssert(fSwapRedAndBlue);
-            builder->fFSCode.appendf("\t%s = tempColor.bgra;\n", outputColor);
+            builder->fFSCode.appendf("\t%s = %s.bgra;\n", outputColor, outputColor);
         } else {
             const char* swiz = fSwapRedAndBlue ? "bgr" : "rgb";
             switch (fPMConversion) {
                 case GrConfigConversionEffect::kMulByAlpha_RoundUp_PMConversion:
                     builder->fFSCode.appendf(
-                        "\t%s = vec4(ceil(tempColor.%s*tempColor.a*255.0)/255.0, tempColor.a);\n",
-                         outputColor, swiz);
+                        "\t\t%s = vec4(ceil(%s.%s * %s.a * 255.0) / 255.0, %s.a);\n",
+                        outputColor, outputColor, swiz, outputColor, outputColor);
                     break;
                 case GrConfigConversionEffect::kMulByAlpha_RoundDown_PMConversion:
                     builder->fFSCode.appendf(
-                        "\t%s = vec4(floor(tempColor.%s*tempColor.a*255.0)/255.0, tempColor.a);\n",
-                         outputColor, swiz);
+                        "\t\t%s = vec4(floor(%s.%s * %s.a * 255.0) / 255.0, %s.a);\n",
+                        outputColor, outputColor, swiz, outputColor, outputColor);
                     break;
                 case GrConfigConversionEffect::kDivByAlpha_RoundUp_PMConversion:
-                    builder->fFSCode.appendf("\t%s = tempColor.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(tempColor.%s / tempColor.a * 255.0)/255.0, tempColor.a);\n",
-                        outputColor, swiz);
+                    builder->fFSCode.appendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n",
+                        outputColor, outputColor, outputColor, swiz, outputColor, outputColor);
                     break;
                 case GrConfigConversionEffect::kDivByAlpha_RoundDown_PMConversion:
-                    builder->fFSCode.appendf("\t%s = tempColor.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(tempColor.%s / tempColor.a * 255.0)/255.0, tempColor.a);\n",
-                        outputColor, swiz);
+                    builder->fFSCode.appendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n",
+                        outputColor, outputColor, outputColor, swiz, outputColor, outputColor);
                     break;
                 default:
                     GrCrash("Unknown conversion op.");
                     break;
             }
         }
+        GrGLSLMulVarBy4f(&builder->fFSCode, 2, outputColor, inputColor);
     }
 
     static inline StageKey GenKey(const GrCustomStage& s, const GrGLCaps&) {
diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index 162a0cc4c..635064fef 100644
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -84,15 +84,11 @@ void GrGLConvolutionEffect::emitFS(GrGLShaderBuilder* builder,
         index.appendS32(i);
         kernel.appendArrayAccess(index.c_str(), &kernelIndex);
         code->appendf("\t\t%s += ", outputColor);
-        builder->emitTextureLookup(samplerName, "coord");
+        builder->appendTextureLookup(&builder->fFSCode, samplerName, "coord");
         code->appendf(" * %s;\n", kernelIndex.c_str());
         code->appendf("\t\tcoord += %s;\n", imgInc);
     }
-
-    if (builder->fModulate.size()) {
-        code->appendf("\t\t%s = %s%s;\n", outputColor, outputColor,
-                      builder->fModulate.c_str());
-    }
+    GrGLSLMulVarBy4f(&builder->fFSCode, 2, outputColor, inputColor);
 }
 
 void GrGLConvolutionEffect::setData(const GrGLUniformManager& uman,
diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp
index 42a8bf950..dc91a68c2 100644
--- a/src/gpu/effects/GrSingleTextureEffect.cpp
+++ b/src/gpu/effects/GrSingleTextureEffect.cpp
@@ -23,7 +23,9 @@ public:
                         const char* outputColor,
                         const char* inputColor,
                         const char* samplerName) SK_OVERRIDE {
-        builder->emitTextureLookupAndModulate(outputColor, samplerName);
+        builder->fFSCode.appendf("\t%s = ", outputColor);
+        builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplerName);
+        builder->fFSCode.append(";\n");
     }
 
     static inline StageKey GenKey(const GrCustomStage&, const GrGLCaps&) { return 0; }
diff --git a/src/gpu/effects/GrTextureDomainEffect.cpp b/src/gpu/effects/GrTextureDomainEffect.cpp
index a67dd49af..f5306c7b0 100644
--- a/src/gpu/effects/GrTextureDomainEffect.cpp
+++ b/src/gpu/effects/GrTextureDomainEffect.cpp
@@ -55,7 +55,9 @@ void GrGLTextureDomainEffect::emitFS(GrGLShaderBuilder* builder,
                            builder->getUniformCStr(fNameUni),
                            builder->getUniformCStr(fNameUni));
 
-    builder->emitTextureLookupAndModulate(outputColor, samplerName, "clampCoord");
+    builder->fFSCode.appendf("\t%s = ", outputColor);
+    builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplerName, "clampCoord");
+    builder->fFSCode.append(";\n");
 }
 
 void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman,
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 50e839b77..ff29bd402 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -987,7 +987,6 @@ void GrGLProgram::genStageCode(int stageNum,
     builder->fVSCode.appendf("\t}\n");
 
     builder->computeSwizzle(desc.fInConfigFlags);
-    builder->computeModulate(fsInColor);
 
     // Enclose custom code in a block to avoid namespace conflicts
     builder->fFSCode.appendf("\t{ // stage %d %s \n",
diff --git a/src/gpu/gl/GrGLSL.cpp b/src/gpu/gl/GrGLSL.cpp
index c995a3465..079c08232 100644
--- a/src/gpu/gl/GrGLSL.cpp
+++ b/src/gpu/gl/GrGLSL.cpp
@@ -115,6 +115,7 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
             outAppend->append(GrGLSLZerosVecf(4));
             return kZeros_GrSLConstantVec;
         } else {
+            // both inputs are ones vectors
             outAppend->append(GrGLSLOnesVecf(4));
             return kOnes_GrSLConstantVec;
         }
@@ -142,6 +143,43 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
     }
 }
 
+namespace {
+void append_tabs(SkString* outAppend, int tabCnt) {
+    static const char kTabs[] = "\t\t\t\t\t\t\t\t";
+    while (tabCnt) {
+        int cnt = GrMin((int)GR_ARRAY_COUNT(kTabs), tabCnt);
+        outAppend->append(kTabs, cnt);
+        tabCnt -= cnt;
+    }
+}
+}
+
+GrSLConstantVec GrGLSLMulVarBy4f(SkString* outAppend,
+                                 int tabCnt,
+                                 const char* vec4VarName,
+                                 const char* mulFactor,
+                                 GrSLConstantVec mulFactorDefault) {
+    bool haveFactor = NULL != mulFactor && '\0' != *mulFactor;
+
+    GrAssert(NULL != outAppend);
+    GrAssert(NULL != vec4VarName);
+    GrAssert(kNone_GrSLConstantVec != mulFactorDefault || haveFactor);
+
+    if (!haveFactor) {
+        if (kOnes_GrSLConstantVec == mulFactorDefault) {
+            return kNone_GrSLConstantVec;
+        } else {
+            GrAssert(kZeros_GrSLConstantVec == mulFactorDefault);
+            append_tabs(outAppend, tabCnt);
+            outAppend->appendf("%s = vec4(0, 0, 0, 0);\n", vec4VarName);
+            return kZeros_GrSLConstantVec;
+        }
+    }
+    append_tabs(outAppend, tabCnt);
+    outAppend->appendf("%s *= %s;\n", vec4VarName, mulFactor);
+    return kNone_GrSLConstantVec;
+}
+
 GrSLConstantVec GrGLSLAdd4f(SkString* outAppend,
                             const char* in0,
                             const char* in1,
diff --git a/src/gpu/gl/GrGLSL.h b/src/gpu/gl/GrGLSL.h
index 659560861..cbff27338 100644
--- a/src/gpu/gl/GrGLSL.h
+++ b/src/gpu/gl/GrGLSL.h
@@ -144,6 +144,19 @@ GrSLConstantVec GrGLSLModulate4f(SkString* outAppend,
                                  GrSLConstantVec default0 = kOnes_GrSLConstantVec,
                                  GrSLConstantVec default1 = kOnes_GrSLConstantVec);
 
+/**
+ * Does an inplace mul, *=, of vec4VarName by mulFactor. If mulFactorDefault is not kNone then
+ * mulFactor may be either "" or NULL. In this case either nothing will be appened (kOnes) or an
+ * assignment of vec(0,0,0,0) will be appended (kZeros). The assignment is prepended by tabCnt tabs.
+ * A semicolon and newline are added after the assignment. (TODO: Remove tabCnt when we auto-insert
+ * tabs to custom stage-generated lines.) If a zeros vec is assigned then the return value is
+ * kZeros, otherwise kNone.
+ */
+GrSLConstantVec GrGLSLMulVarBy4f(SkString* outAppend,
+                                 int tabCnt,
+                                 const char* vec4VarName,
+                                 const char* mulFactor,
+                                 GrSLConstantVec mulFactorDefault = kOnes_GrSLConstantVec);
 
 /**
   * Produces a string that is the result of adding two inputs. The inputs must be vec4 or float.
diff --git a/src/gpu/gl/GrGLShaderBuilder.cpp b/src/gpu/gl/GrGLShaderBuilder.cpp
index c0614684b..5d870dd41 100644
--- a/src/gpu/gl/GrGLShaderBuilder.cpp
+++ b/src/gpu/gl/GrGLShaderBuilder.cpp
@@ -96,14 +96,6 @@ void GrGLShaderBuilder::computeSwizzle(uint32_t configFlags) {
     }
 }
 
-void GrGLShaderBuilder::computeModulate(const char* fsInColor) {
-    if (NULL != fsInColor) {
-        fModulate.printf(" * %s", fsInColor);
-    } else {
-        fModulate.reset();
-    }
-}
-
 void GrGLShaderBuilder::setupTextureAccess(const char* varyingFSName, GrSLType varyingType) {
     // FIXME: We don't know how the custom stage will manipulate the coords. So we give up on using
     // projective texturing and always give the stage 2D coords. This will be fixed when custom
@@ -130,23 +122,27 @@ void GrGLShaderBuilder::setupTextureAccess(const char* varyingFSName, GrSLType v
     }
 }
 
-void GrGLShaderBuilder::emitTextureLookup(const char* samplerName,
-                                          const char* coordName,
-                                          GrSLType varyingType) {
+void GrGLShaderBuilder::appendTextureLookup(SkString* out,
+                                            const char* samplerName,
+                                            const char* coordName,
+                                            GrSLType varyingType) const {
     if (NULL == coordName) {
         coordName = fDefaultTexCoordsName.c_str();
         varyingType = kVec2f_GrSLType;
     }
-    fFSCode.appendf("%s(%s, %s)", sample_function_name(varyingType), samplerName, coordName);
+    out->appendf("%s(%s, %s)", sample_function_name(varyingType), samplerName, coordName);
 }
 
-void GrGLShaderBuilder::emitTextureLookupAndModulate(const char* outColor,
-                                                     const char* samplerName,
-                                                     const char* coordName,
-                                                     GrSLType varyingType) {
-    fFSCode.appendf("\t%s = ", outColor);
-    this->emitTextureLookup(samplerName, coordName, varyingType);
-    fFSCode.appendf("%s%s;\n", fSwizzle.c_str(), fModulate.c_str());
+void GrGLShaderBuilder::appendTextureLookupAndModulate(SkString* out,
+                                                       const char* modulation,
+                                                       const char* samplerName,
+                                                       const char* coordName,
+                                                       GrSLType varyingType) const {
+    GrAssert(NULL != out);
+    SkString lookup;
+    this->appendTextureLookup(&lookup, samplerName, coordName, varyingType);
+    lookup.append(fSwizzle.c_str());
+    GrGLSLModulate4f(out, modulation, lookup.c_str());
 }
 
 void GrGLShaderBuilder::emitCustomTextureLookup(const GrTextureAccess& textureAccess,
diff --git a/src/gpu/gl/GrGLShaderBuilder.h b/src/gpu/gl/GrGLShaderBuilder.h
index 66de5abdc..bc108923f 100644
--- a/src/gpu/gl/GrGLShaderBuilder.h
+++ b/src/gpu/gl/GrGLShaderBuilder.h
@@ -32,7 +32,6 @@ public:
     GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&);
 
     void computeSwizzle(uint32_t configFlags);
-    void computeModulate(const char* fsInColor);
 
     /** Determines whether we should use texture2D() or texture2Dproj(), and if an explicit divide
         is required for the sample coordinates, creates the new variable and emits the code to
@@ -42,17 +41,20 @@ public:
     /** texture2D(samplerName, coordName), with projection if necessary; if coordName is not
         specified, uses fSampleCoords. coordType must either be Vec2f or Vec3f. The latter is
         interpreted as projective texture coords. */
-    void emitTextureLookup(const char* samplerName,
-                           const char* coordName = NULL,
-                           GrSLType coordType = kVec2f_GrSLType);
+    void appendTextureLookup(SkString* out,
+                             const char* samplerName,
+                             const char* coordName = NULL,
+                             GrSLType coordType = kVec2f_GrSLType) const;
 
-    /** sets outColor to results of texture lookup, with swizzle, and/or modulate as necessary. If
-    coordName is NULL then it as if defaultTexCoordsName() was passed. coordType must be either
-    kVec2f or kVec3f. */
-    void emitTextureLookupAndModulate(const char* outColor,
-                                      const char* samplerName,
-                                      const char* coordName = NULL,
-                                      GrSLType coordType = kVec2f_GrSLType);
+    /** appends a texture lookup, with swizzle as necessary. If coordName is NULL then it as if
+        defaultTexCoordsName() was passed. coordType must be either kVec2f or kVec3f. If modulateVar
+        is not NULL or "" then the texture lookup will be modulated by it. modulation must refer to
+        be expression that evaluates to a float or vec4. */
+    void appendTextureLookupAndModulate(SkString* out,
+                                        const char* modulation,
+                                        const char* samplerName,
+                                        const char* coordName = NULL,
+                                        GrSLType varyingType = kVec2f_GrSLType) const;
 
     /** Gets the name of the default texture coords which are always kVec2f */
     const char* defaultTexCoordsName() const { return fDefaultTexCoordsName.c_str(); }
@@ -171,7 +173,6 @@ public:
     //@{
 
     SkString         fSwizzle;
-    SkString         fModulate;
 
     //@}