Stop lieing about GrBatch color for Rects

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
@@ skipping 52 matching lines @@
     };
 
     static GrBatch* Create(const Geometry& geometry, const GrIndexBuffer* indexBuffer) {
         return SkNEW_ARGS(AAFillRectBatch, (geometry, indexBuffer));
     }
 
     const char* name() const SK_OVERRIDE { return "AAFillRectBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
         // When this is called on a batch, there is only one geometry bundle
-        if (!this->canTweakAlphaForCoverage() && GrColorIsOpaque(fGeoData[0].fColor)) {
-            out->setUnknownOpaqueFourComponents();
-        } else {
-            out->setUnknownFourComponents();
-        }
+        out->setKnownFourComponents(fGeoData[0].fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
-        if (this->canTweakAlphaForCoverage()) {
-            // uniform coverage
-            out->setKnownSingleComponent(0xff);
-        } else {
-            out->setUnknownSingleComponent();
-        }
-    }
-
-    void initBatchOpt(const GrBatchOpt& batchOpt) {
-        fBatchOpt = batchOpt;
+        out->setUnknownSingleComponent();
     }
 
     void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
         // Handle any color overrides
         if (init.fColorIgnored) {
             fGeoData[0].fColor = GrColor_ILLEGAL;
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             fGeoData[0].fColor = init.fOverrideColor;
         }
 
         // setup batch properties
         fBatch.fColorIgnored = init.fColorIgnored;
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = init.fUsesLocalCoords;
         fBatch.fCoverageIgnored = init.fCoverageIgnored;
+        fBatch.fCanTweakAlphaForCoverage = init.fCanTweakAlphaForCoverage;
     }
 
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
         SkMatrix localMatrix;
         if (!this->viewMatrix().invert(&localMatrix)) {
             SkDebugf("Cannot invert\n");
             return;
         }
@@ skipping 71 matching lines @@
 
 private:
     AAFillRectBatch(const Geometry& geometry, const GrIndexBuffer* indexBuffer)
         : fIndexBuffer(indexBuffer) {
         this->initClassID<AAFillRectBatch>();
         fGeoData.push_back(geometry);
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
-    bool canTweakAlphaForCoverage() const { return fBatchOpt.fCanTweakAlphaForCoverage; }
+    bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
 
     bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
         AAFillRectBatch* that = t->cast<AAFillRectBatch>();
-        if (this->canTweakAlphaForCoverage() != that->canTweakAlphaForCoverage()) {
-            return false;
-        }
-
-        if (this->colorIgnored() != that->colorIgnored()) {
-            return false;
-        }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         if (this->color() != that->color()) {
             fBatch.fColor = GrColor_ILLEGAL;
         }
+
+        // In the event of two batches, one who can tweak, one who cannot, we just fall back to
+        // not tweaking
+        if (this->canTweakAlphaForCoverage() != that->canTweakAlphaForCoverage()) {
+            fBatch.fCanTweakAlphaForCoverage = false;
+        }
+
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         return true;
     }
 
     void generateAAFillRectGeometry(void* vertices,
                                     size_t offset,
                                     size_t vertexStride,
                                     GrColor color,
                                     const SkMatrix& viewMatrix,
                                     const SkRect& rect,
@@ skipping 82 matching lines @@
                                           sizeof(GrColor)) = innerCoverage;
             }
         }
     }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
+        bool fCanTweakAlphaForCoverage;
     };
 
-    GrBatchOpt fBatchOpt;
     BatchTracker fBatch;
     const GrIndexBuffer* fIndexBuffer;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
@@ skipping 383 matching lines @@
 
     if (devInside.isEmpty()) {
         this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                          devOutside);
         return;
     }
 
     this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                                devOutsideAssist, devInside, true);
 }