Revert of Add isSingleComponent bool to getConstantColorComponent

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "gl/builders/GrGLFullProgramBuilder.h"
@@ skipping 57 matching lines @@
 
         if (stroke) {
             gCircleStrokeEdge->ref();
             return gCircleStrokeEdge;
         } else {
             gCircleFillEdge->ref();
             return gCircleFillEdge;
         }
     }
 
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
     const GrShaderVar& inCircleEdge() const { return fInCircleEdge; }
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<CircleEdgeEffect>::getInstance();
     }
 
     virtual ~CircleEdgeEffect() {}
 
     static const char* Name() { return "CircleEdge"; }
 
@@ skipping 50 matching lines @@
                             kVec4f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE {
         const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
         return cee.fStroke == fStroke;
     }
 
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
-        inout->fValidFlags = 0;
-        inout->fIsSingleComponent = false;
-    }
-
     const GrShaderVar& fInCircleEdge;
     bool fStroke;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleEdgeEffect);
 
@@ skipping 22 matching lines @@
 
         if (stroke) {
             gEllipseStrokeEdge->ref();
             return gEllipseStrokeEdge;
         } else {
             gEllipseFillEdge->ref();
             return gEllipseFillEdge;
         }
     }
 
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<EllipseEdgeEffect>::getInstance();
     }
 
     virtual ~EllipseEdgeEffect() {}
 
     static const char* Name() { return "EllipseEdge"; }
 
     const GrShaderVar& inEllipseOffset() const { return fInEllipseOffset; }
     const GrShaderVar& inEllipseRadii() const { return fInEllipseRadii; }
@@ skipping 74 matching lines @@
                             kVec4f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE {
         const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>();
         return eee.fStroke == fStroke;
     }
 
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
-        inout->fValidFlags = 0;
-        inout->fIsSingleComponent = false;
-    }
-
     const GrShaderVar& fInEllipseOffset;
     const GrShaderVar& fInEllipseRadii;
     bool fStroke;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseEdgeEffect);
@@ skipping 30 matching lines @@
             return gEllipseStrokeEdge;
         } else if (kHairline == mode) {
             gEllipseHairlineEdge->ref();
             return gEllipseHairlineEdge;
         } else {
             gEllipseFillEdge->ref();
             return gEllipseFillEdge;
         }
     }
 
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<DIEllipseEdgeEffect>::getInstance();
     }
 
     virtual ~DIEllipseEdgeEffect() {}
 
     static const char* Name() { return "DIEllipseEdge"; }
 
     const GrShaderVar& inEllipseOffsets0() const { return fInEllipseOffsets0; }
     const GrShaderVar& inEllipseOffsets1() const { return fInEllipseOffsets1; }
@@ skipping 94 matching lines @@
                             kVec2f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         fMode = mode;
     }
 
     virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE {
         const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>();
         return eee.fMode == fMode;
     }
 
-    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
-        inout->fValidFlags = 0;
-        inout->fIsSingleComponent = false;
-    }
-
     const GrShaderVar& fInEllipseOffsets0;
     const GrShaderVar& fInEllipseOffsets1;
     Mode fMode;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseEdgeEffect);
@@ skipping 764 matching lines @@
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds);
     }
 
     return true;
 }