Initial CL to move color / coverage off of drawstate

src/gpu/GrDefaultGeoProcFactory.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 "GrDefaultGeoProcFactory.h"
 
 #include "GrDrawState.h"
 #include "GrInvariantOutput.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 typedef GrDefaultGeoProcFactory Flag;
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(uint32_t gpTypeFlags) {
-        return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags));
+    static GrGeometryProcessor* Create(GrColor color, uint8_t coverage, uint32_t gpTypeFlags) {
+        return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags));
     }
 
     virtual const char* name() const SK_OVERRIDE { return "DefaultGeometryProcessor"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inColor() const { return fInColor; }
     const GrAttribute* inLocalCoords() const { return fInLocalCoords; }
     const GrAttribute* inCoverage() const { return fInCoverage; }
 
     class GLProcessor : public GrGLGeometryProcessor {
@@ skipping 52 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    DefaultGeoProc(uint32_t gpTypeFlags)
-        : fInPosition(NULL)
+    DefaultGeoProc(GrColor color, uint8_t coverage, uint32_t gpTypeFlags)
+        : INHERITED(color, coverage)
+        , fInPosition(NULL)
         , fInColor(NULL)
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fFlags(gpTypeFlags) {
         this->initClassID<DefaultGeoProc>();
         bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
         bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
         bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         if (hasColor) {
@@ skipping 26 matching lines @@
     }
 
     const GrAttribute* fInPosition;
     const GrAttribute* fInColor;
     const GrAttribute* fInLocalCoords;
     const GrAttribute* fInCoverage;
     uint32_t fFlags;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
-    typedef GrFragmentProcessor INHERITED;
+    typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
 
 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random,
                                                 GrContext*,
                                                 const GrDrawTargetCaps& caps,
                                                 GrTexture*[]) {
     uint32_t flags = 0;
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     }
 
-    return DefaultGeoProc::Create(flags);
+    return DefaultGeoProc::Create(GrRandomColor(random), GrRandomCoverage(random), flags);
 }
 
-const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags) {
-    return DefaultGeoProc::Create(gpTypeFlags);
+const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(GrColor color, uint32_t gpTypeFlags,
+                                                           uint8_t coverage) {
+    return DefaultGeoProc::Create(color, coverage, gpTypeFlags);
 }