Remove gpu shader optimatization for solid white or trans black colors

Running test on the added bench which draws a grid of all white paths, all blue paths, or alternating checkered white/blue paths.

With optimization in (ms):
         White       Blue        Checkered
Linux    ~80         ~80         ~160
N7       ~800        ~1100       ~1500
Moto-e   ~830        ~1100       ~2500

Without optimization in (ms):
         White       Blue        Checkered
Linux    ~80         ~80         ~80
N7       ~1100       ~1100       ~1100
Moto-e   ~1100       ~1100       ~1500

BUG=skia:

Committed: https://skia.googlesource.com/skia/+/5f78d2251a440443c9eaa321dad058d7a32bfef7

R=bsalomon@google.com

Author: egdaniel@google.com

Review URL: https://codereview.chromium.org/375823005

11 files changed, 242 insertions, 31 deletions

diff --git a/bench/AlternatingColorPatternBench.cpp b/bench/AlternatingColorPatternBench.cpp
new file mode 100644
index 0000000000..b497979a89
--- /dev/null
+++ b/bench/AlternatingColorPatternBench.cpp
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Benchmark.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkPaint.h"
+#include "SkString.h"
+
+enum ColorPattern {
+    kWhite_ColorPattern,
+    kBlue_ColorPattern,
+    kOpaqueBitmap_ColorPattern,
+    kAlphaBitmap_ColorPattern,
+};
+
+static const struct ColorPatternData{
+    SkColor         fColor;
+    bool            fIsBitmap;
+    const char*     fName;
+} gColorPatterns[] = {
+    // Keep this in same order as ColorPattern enum
+    { SK_ColorWHITE, false,  "white"        }, // kWhite_ColorPattern
+    { SK_ColorBLUE,  false,  "blue"         }, // kBlue_ColorPattern
+    { SK_ColorWHITE, true,   "obaqueBitMap" }, // kOpaqueBitmap_ColorPattern
+    { 0x10000000,    true,   "alphaBitmap"  }, // kAlphaBitmap_ColorPattern
+};
+
+enum DrawType {
+    kRect_DrawType,
+    kPath_DrawType,
+};
+
+static void makebm(SkBitmap* bm, int w, int h) {
+    bm->allocN32Pixels(w, h);
+    bm->eraseColor(SK_ColorTRANSPARENT);
+
+    SkCanvas    canvas(*bm);
+    SkScalar    s = SkIntToScalar(SkMin32(w, h));
+    static const SkPoint     kPts0[] = { { 0, 0 }, { s, s } };
+    static const SkPoint     kPts1[] = { { s/2, 0 }, { s/2, s } };
+    static const SkScalar    kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
+    static const SkColor kColors0[] = {0x80F00080, 0xF0F08000, 0x800080F0 };
+    static const SkColor kColors1[] = {0xF08000F0, 0x8080F000, 0xF000F080 };
+
+
+    SkPaint     paint;
+
+    paint.setShader(SkGradientShader::CreateLinear(kPts0, kColors0, kPos,
+                    SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode))->unref();
+    canvas.drawPaint(paint);
+    paint.setShader(SkGradientShader::CreateLinear(kPts1, kColors1, kPos,
+                    SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode))->unref();
+    canvas.drawPaint(paint);
+}
+
+/**
+ * This bench draws a grid of either rects or filled paths, with two alternating color patterns.
+ * This color patterns are passed in as enums to the class. The options are:
+ *   1) solid white color
+ *   2) solid blue color
+ *   3) opaque bitmap
+ *   4) partial alpha bitmap
+ * The same color pattern can be set for both arguments to create a uniform pattern on all draws.
+ *
+ * The bench is used to test a few things. First it can test any optimizations made for a specific
+ * color pattern (for example drawing an opaque bitmap versus one with partial alpha). Also it can
+ * be used to test the cost of program switching and/or batching when alternating between different
+ * patterns when on the gpu.
+ */
+class AlternatingColorPatternBench : public Benchmark {
+public:
+    enum {
+        NX = 5,
+        NY = 5,
+        NUM_DRAWS = NX * NY,
+    };
+    SkShader* fBmShader;
+
+    SkPath  fPaths[NUM_DRAWS];
+    SkRect  fRects[NUM_DRAWS];
+    SkColor fColors[NUM_DRAWS];
+    SkShader* fShaders[NUM_DRAWS];
+
+    SkString        fName;
+    ColorPatternData    fPattern1;
+    ColorPatternData    fPattern2;
+    DrawType fDrawType;
+    SkBitmap fBmp;
+
+
+    AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType)
+        : fBmShader(NULL) {
+        fPattern1 = gColorPatterns[pattern1];
+        fPattern2 = gColorPatterns[pattern2];
+        fName.printf("colorPattern_%s_%s_%s",
+                     fPattern1.fName, fPattern2.fName,
+                     kRect_DrawType == drawType ? "rect" : "path");
+        fDrawType = drawType;
+    }
+
+    virtual ~AlternatingColorPatternBench() {
+        SkSafeUnref(fBmShader);
+    }
+
+protected:
+    virtual const char* onGetName() SK_OVERRIDE {
+        return fName.c_str();
+    }
+
+    virtual void onPreDraw() {
+        int w = 40;
+        int h = 40;
+        makebm(&fBmp, w, h);
+        fBmShader = SkShader::CreateBitmapShader(fBmp,
+                                                 SkShader::kRepeat_TileMode,
+                                                 SkShader::kRepeat_TileMode);
+        int offset = 2;
+        int count = 0;
+        for (int j = 0; j < NY; ++j) {
+            for (int i = 0; i < NX; ++i) {
+                int x = (w + offset) * i;
+                int y = (h * offset) * j;
+                if (kRect_DrawType == fDrawType) {
+                    fRects[count].set(SkIntToScalar(x), SkIntToScalar(y),
+                                      SkIntToScalar(x + w), SkIntToScalar(y + h));
+                } else {
+                    fPaths[count].moveTo(SkIntToScalar(x), SkIntToScalar(y));
+                    fPaths[count].rLineTo(SkIntToScalar(w), 0);
+                    fPaths[count].rLineTo(0, SkIntToScalar(h));
+                    fPaths[count].rLineTo(SkIntToScalar(-w + 1), 0);
+                }
+                if (0 == count % 2) {
+                    fColors[count]  = fPattern1.fColor;
+                    fShaders[count] = fPattern1.fIsBitmap ? fBmShader : NULL;
+                } else {
+                    fColors[count]  = fPattern2.fColor;
+                    fShaders[count] = fPattern2.fIsBitmap ? fBmShader : NULL;
+                }
+                ++count;
+            }
+        }
+    }
+
+    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+        SkPaint paint;
+        paint.setAntiAlias(false);
+        paint.setFilterLevel(SkPaint::kLow_FilterLevel);
+
+        for (int i = 0; i < loops; ++i) {
+            for (int j = 0; j < NUM_DRAWS; ++j) {
+                paint.setColor(fColors[j]);
+                paint.setShader(fShaders[j]);
+                if (kRect_DrawType == fDrawType) {
+                    canvas->drawRect(fRects[j], paint);
+                } else {
+                    canvas->drawPath(fPaths[j], paint);
+                }
+            }
+        }
+    }
+
+private:
+    typedef Benchmark INHERITED;
+};
+
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kWhite_ColorPattern, kWhite_ColorPattern,
+                              kPath_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kBlue_ColorPattern, kBlue_ColorPattern,
+                              kPath_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kWhite_ColorPattern, kBlue_ColorPattern,
+                              kPath_DrawType)); )
+
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
+                              kPath_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
+                              kPath_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
+                              kPath_DrawType)); )
+
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kOpaqueBitmap_ColorPattern, kOpaqueBitmap_ColorPattern,
+                              kRect_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kAlphaBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
+                              kRect_DrawType)); )
+DEF_BENCH( return SkNEW_ARGS(AlternatingColorPatternBench,
+                             (kOpaqueBitmap_ColorPattern, kAlphaBitmap_ColorPattern,
+                              kRect_DrawType)); )
+
diff --git a/expectations/gm/ignored-tests.txt b/expectations/gm/ignored-tests.txt
index c97a0b9de2..d8c0476c09 100644
--- a/expectations/gm/ignored-tests.txt
+++ b/expectations/gm/ignored-tests.txt
@@ -33,6 +33,18 @@
 ## epoger will rebaseline by 25 Dec 2013
 #gradtext
 
+# egdaniel: removing a gpu shader optimization causes some single pixel changes in gm
+# cl: https://codereview.chromium.org/375823005/#ps210001
+coloremoji
+complexclip2
+complexclip2_path_bw
+complexclip2_rrect_bw
+gradients_view_perspective
+imagefiltersbase
+inverse_paths
+xfermodes3
+verylargebitmap
+
 # reed: bitmapfilters changed (labels) with hide_config CL, just need rebaselines
 bitmapfilters
 
diff --git a/gyp/bench.gypi b/gyp/bench.gypi
index c8d20616e5..b8406e2efa 100644
--- a/gyp/bench.gypi
+++ b/gyp/bench.gypi
@@ -23,6 +23,7 @@
     '../bench/Benchmark.h',
 
     '../bench/AAClipBench.cpp',
+    '../bench/AlternatingColorPatternBench.cpp',
     '../bench/BitmapBench.cpp',
     '../bench/BitmapRectBench.cpp',
     '../bench/BitmapScaleBench.cpp',
diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp
index 14ba6fad5d..02c7920f5d 100644
--- a/src/gpu/GrDrawState.cpp
+++ b/src/gpu/GrDrawState.cpp
@@ -409,6 +409,15 @@ GrDrawState::BlendOptFlags GrDrawState::calcBlendOpts(bool forceCoverage,
     return kNone_BlendOpt;
 }
 
+bool GrDrawState::canIgnoreColorAttribute() const {
+    if (fBlendOptFlags & kInvalid_BlendOptFlag) {
+        this->getBlendOpts();
+    }
+    return SkToBool(fBlendOptFlags & (GrDrawState::kEmitTransBlack_BlendOptFlag |
+                                      GrDrawState::kEmitCoverage_BlendOptFlag));
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::AutoViewMatrixRestore::restore() {
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index cef21af880..c1dd9dcd36 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -551,6 +551,12 @@ public:
     }
 
     /**
+     * We don't use suplied vertex color attributes if our blend mode is EmitCoverage or
+     * EmitTransBlack
+     */
+    bool canIgnoreColorAttribute() const;
+
+    /**
      * Determines what optimizations can be applied based on the blend. The coefficients may have
      * to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional
      * params that receive the tweaked coefficients. Normally the function looks at the current
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 435d0cdb02..5bc7d0b277 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -154,7 +154,7 @@ void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
-    if (!drawState.hasColorVertexAttribute()) {
+    if (!drawState.hasColorVertexAttribute() || drawState.canIgnoreColorAttribute()) {
         switch (header.fColorInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
                 SkASSERT(-1 != header.fColorAttributeIndex);
@@ -178,12 +178,8 @@ void GrGLProgram::setColor(const GrDrawState& drawState,
                 }
                 sharedState->fConstAttribColorIndex = -1;
                 break;
-            case GrGLProgramDesc::kSolidWhite_ColorInput:
-            case GrGLProgramDesc::kTransBlack_ColorInput:
-                sharedState->fConstAttribColorIndex = -1;
-                break;
             default:
-                SkFAIL("Unknown color type.");
+                SkFAIL("Unexpected color type.");
         }
     } else {
         sharedState->fConstAttribColorIndex = -1;
@@ -218,11 +214,10 @@ void GrGLProgram::setCoverage(const GrDrawState& drawState,
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
-            case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             default:
-                SkFAIL("Unknown coverage type.");
+                SkFAIL("Unexpected coverage type.");
         }
     } else {
         sharedState->fConstAttribCoverageIndex = -1;
diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp
index 27a1fab1e0..e1a319104d 100644
--- a/src/gpu/gl/GrGLProgramDesc.cpp
+++ b/src/gpu/gl/GrGLProgramDesc.cpp
@@ -66,6 +66,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
 
     bool skipColor = SkToBool(blendOpts & (GrDrawState::kEmitTransBlack_BlendOptFlag |
                                            GrDrawState::kEmitCoverage_BlendOptFlag));
+
     int firstEffectiveColorStage = 0;
     bool inputColorIsUsed = true;
     if (!skipColor) {
@@ -99,11 +100,6 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
     bool requiresLocalCoordAttrib = !(skipCoverage  && skipColor) &&
                                     drawState.hasLocalCoordAttribute();
 
-    bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
-    bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) ||
-                             (!requiresColorAttrib && 0xffffffff == drawState.getColor()) ||
-                             (!inputColorIsUsed);
-
     bool readsDst = false;
     bool readFragPosition = false;
     // We use vertexshader-less shader programs only when drawing paths.
@@ -192,11 +188,7 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
 #endif
     bool defaultToUniformInputs = GR_GL_NO_CONSTANT_ATTRIBUTES || gpu->caps()->pathRenderingSupport();
 
-    if (colorIsTransBlack) {
-        header->fColorInput = kTransBlack_ColorInput;
-    } else if (colorIsSolidWhite) {
-        header->fColorInput = kSolidWhite_ColorInput;
-    } else if (defaultToUniformInputs && !requiresColorAttrib) {
+    if (defaultToUniformInputs && !requiresColorAttrib && inputColorIsUsed) {
         header->fColorInput = kUniform_ColorInput;
     } else {
         header->fColorInput = kAttribute_ColorInput;
@@ -205,11 +197,9 @@ bool GrGLProgramDesc::Build(const GrDrawState& drawState,
 
     bool covIsSolidWhite = !requiresCoverageAttrib && 0xffffffff == drawState.getCoverageColor();
 
-    if (skipCoverage) {
-        header->fCoverageInput = kTransBlack_ColorInput;
-    } else if (covIsSolidWhite || !inputCoverageIsUsed) {
+    if ((covIsSolidWhite || !inputCoverageIsUsed) && !skipCoverage) {
         header->fCoverageInput = kSolidWhite_ColorInput;
-    } else if (defaultToUniformInputs && !requiresCoverageAttrib) {
+    } else if (defaultToUniformInputs && !requiresCoverageAttrib && inputCoverageIsUsed) {
         header->fCoverageInput = kUniform_ColorInput;
     } else {
         header->fCoverageInput = kAttribute_ColorInput;
diff --git a/src/gpu/gl/GrGLProgramDesc.h b/src/gpu/gl/GrGLProgramDesc.h
index a8d27ab269..cccdee9ce2 100644
--- a/src/gpu/gl/GrGLProgramDesc.h
+++ b/src/gpu/gl/GrGLProgramDesc.h
@@ -100,7 +100,6 @@ private:
     // Specifies where the initial color comes from before the stages are applied.
     enum ColorInput {
         kSolidWhite_ColorInput,
-        kTransBlack_ColorInput,
         kAttribute_ColorInput,
         kUniform_ColorInput,
 
diff --git a/src/gpu/gl/GrGLShaderBuilder.cpp b/src/gpu/gl/GrGLShaderBuilder.cpp
index 7a57d8e32e..8d1e66be7c 100644
--- a/src/gpu/gl/GrGLShaderBuilder.cpp
+++ b/src/gpu/gl/GrGLShaderBuilder.cpp
@@ -164,10 +164,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],
             this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Color",
                              &name);
         inputColor = GrGLSLExpr4(name);
-    } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fColorInput) {
-        inputColor = GrGLSLExpr4(1);
-    } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fColorInput) {
-        inputColor = GrGLSLExpr4(0);
     }
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
@@ -178,8 +174,6 @@ bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],
         inputCoverage = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
         inputCoverage = GrGLSLExpr4(1);
-    } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fCoverageInput) {
-        inputCoverage = GrGLSLExpr4(0);
     }
 
     if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index 9e1b6f5c2b..45181c25a8 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -353,9 +353,12 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
         uint32_t usedAttribArraysMask = 0;
         const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs();
 
+        bool canIgnoreColorAttrib = this->getDrawState().canIgnoreColorAttribute();
+
         for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount;
              ++vertexAttribIndex, ++vertexAttrib) {
 
+            if (kColor_GrVertexAttribBinding != vertexAttrib->fBinding || !canIgnoreColorAttrib) {
             usedAttribArraysMask |= (1 << vertexAttribIndex);
             GrVertexAttribType attribType = vertexAttrib->fType;
             attribState->set(this,
@@ -367,6 +370,7 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
                              stride,
                              reinterpret_cast<GrGLvoid*>(
                                  vertexOffsetInBytes + vertexAttrib->fOffset));
+            }
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 899b42fb4f..9da1ecc53c 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -73,8 +73,9 @@ bool GrGLProgramDesc::setRandom(SkRandom* random,
     // if the effects have used up all off the available attributes,
     // don't try to use color or coverage attributes as input
     do {
-        header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>(
-                                  random->nextULessThan(kColorInputCnt));
+        uint32_t colorRand = random->nextULessThan(2);
+        header->fColorInput = (0 == colorRand) ? GrGLProgramDesc::kAttribute_ColorInput :
+                                                 GrGLProgramDesc::kUniform_ColorInput;
     } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex &&
              kAttribute_ColorInput == header->fColorInput);