Draft change to start pulling uniform color into GP

src/gpu/GrOptDrawState.cpp

 /*
  * 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 "GrOptDrawState.h"
 
 #include "GrDrawState.h"
@@ skipping 105 matching lines @@
                                (drawState.fCoverageStages[i], hasLocalCoords));
     }
 
     this->setOutputStateInfo(drawState, blendOpt, caps);
 
     // let the GP init the batch tracker
     if (drawState.hasGeometryProcessor()) {
         GrGeometryProcessor::InitBT init;
         init.fOutputColor = fDescInfo.fInputColorIsUsed;
         init.fOutputCoverage = fDescInfo.fInputCoverageIsUsed;
+        init.fRemoveColorAttr = !fDescInfo.fHasVertexColor;
+        init.fRemoveCoverageAttr = !fDescInfo.fHasVertexCoverage;
         init.fColor = this->getColor();
-        init.fCoverage = this->getCoverage();
+        init.fCoverage = this->getCoverageColor();
         fGeometryProcessor->initBatchTracker(&fBatchTracker, init);
     }
 }
 
 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
                                         GrDrawState::BlendOpt blendOpt,
                                         const GrDrawTargetCaps& caps) {
     // Set this default and then possibly change our mind if there is coverage.
     fDescInfo.fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
     fDescInfo.fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
@@ skipping 118 matching lines @@
         return false;
     }
 
     if (!fDescInfo.fHasVertexCoverage && this->fCoverage != that.fCoverage) {
         return false;
     }
 
     if (this->hasGeometryProcessor()) {
         if (!that.hasGeometryProcessor()) {
             return false;
         } else if (!this->getGeometryProcessor()->isEqual(*that.getGeometryProcessor())) {

[bsalomon, 2014/12/05 14:43:03]

Should we get rid of isEqual() in favor of canBatch?

Howabout

/* non-virtual */ bool GrGP::canBatch(that) {
   if (this->classID() == that.classID()) {
        return /*virtual*/ this->onCanBatch(that);
   }
   return false;
}

             return false;
+        } else if (this->getGeometryProcessor()->fNewStyle) {
+            if (!this->getGeometryProcessor()->canBatch(this->getBatchTracker(),
+                                                        that.getBatchTracker())) {
+                return false;
+            }
         }
     } else if (that.hasGeometryProcessor()) {
         return false;
     }
 
     // The program desc comparison should have already assured that the stage counts match.
     SkASSERT(this->numFragmentStages() == that.numFragmentStages());
     for (int i = 0; i < this->numFragmentStages(); i++) {
 
         if (this->getFragmentStage(i) != that.getFragmentStage(i)) {
             return false;
         }
     }
+
     return true;
 }