More changes to bring together path / geo procs

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"
@@ skipping 19 matching lines @@
         return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags,
                                            color,
                                            viewMatrix,
                                            localMatrix,
                                            opaqueVertexColors,
                                            coverage));
     }
 
     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; }
+    const Attribute* inPosition() const { return fInPosition; }
+    const Attribute* inColor() const { return fInColor; }
+    const Attribute* inLocalCoords() const { return fInLocalCoords; }
+    const Attribute* inCoverage() const { return fInCoverage; }
     uint8_t coverage() const { return fCoverage; }
 
     void initBatchTracker(GrBatchTracker* bt, const InitBT& init) const SK_OVERRIDE {
         BatchTracker* local = bt->cast<BatchTracker>();
         local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
                                                    SkToBool(fInColor));
 
         bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored;
         bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage();
         if (covIsSolidWhite) {
@@ skipping 144 matching lines @@
         , fInPosition(NULL)
         , fInColor(NULL)
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fCoverage(coverage)
         , 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));
+        fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
         if (hasColor) {
-            fInColor = &this->addVertexAttrib(GrAttribute("inColor", kVec4ub_GrVertexAttribType));
+            fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
             this->setHasVertexColor();
         }
         if (hasLocalCoord) {
-            fInLocalCoords = &this->addVertexAttrib(GrAttribute("inLocalCoord",
+            fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord",
                                                                 kVec2f_GrVertexAttribType));
             this->setHasLocalCoords();
         }
         if (hasCoverage) {
-            fInCoverage = &this->addVertexAttrib(GrAttribute("inCoverage",
+            fInCoverage = &this->addVertexAttrib(Attribute("inCoverage",
                                                              kFloat_GrVertexAttribType));
         }
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
         return gp.fFlags == this->fFlags;
     }
 
     virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
         if (fInCoverage) {
             out->setUnknownSingleComponent();
         } else {
             // uniform coverage
             out->setKnownSingleComponent(this->coverage());
         }
     }
 
     struct BatchTracker {
         GrGPInput fInputColorType;
         GrGPInput fInputCoverageType;
         GrColor  fColor;
         GrColor  fCoverage;
         bool fUsesLocalCoords;
     };
 
-    const GrAttribute* fInPosition;
-    const GrAttribute* fInColor;
-    const GrAttribute* fInLocalCoords;
-    const GrAttribute* fInCoverage;
+    const Attribute* fInPosition;
+    const Attribute* fInColor;
+    const Attribute* fInLocalCoords;
+    const Attribute* fInCoverage;
     uint8_t fCoverage;
     uint32_t fFlags;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
 
@@ skipping 26 matching lines @@
                                                            const SkMatrix& localMatrix,
                                                            bool opaqueVertexColors,
                                                            uint8_t coverage) {
     return DefaultGeoProc::Create(gpTypeFlags,
                                   color,
                                   viewMatrix,
                                   localMatrix,
                                   opaqueVertexColors,
                                   coverage);
 }