Add isSingleComponent bool to getConstantColorComponent

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 "GrGpu.h"
 #include "gl/builders/GrGLFullProgramBuilder.h"
@@ skipping 12 matching lines @@
     static GrGeometryProcessor* Create() {
         GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gAlignedRectEffect, GrAlignedRectEffect, ());
         gAlignedRectEffect->ref();
         return gAlignedRectEffect;
     }
 
     virtual ~GrAlignedRectEffect() {}
 
     static const char* Name() { return "AlignedRectEdge"; }
 
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
     const GrShaderVar& inRect() const { return fInRect; }
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<GrAlignedRectEffect>::getInstance();
     }
 
     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
         : INHERITED (factory) {}
@@ skipping 57 matching lines @@
     GrAlignedRectEffect()
         : fInRect(this->addVertexAttrib(GrShaderVar("inRect",
                                                     kVec4f_GrSLType,
                                                     GrShaderVar::kAttribute_TypeModifier))) {
     }
 
     const GrShaderVar& fInRect;
 
     virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE { return true; }
 
+    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
+        inout->fValidFlags = 0;
+        inout->fIsSingleComponent = false;
+    }
+
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrAlignedRectEffect);
 
 GrGeometryProcessor* GrAlignedRectEffect::TestCreate(SkRandom* random,
                                                      GrContext* context,
@@ skipping 23 matching lines @@
     static GrGeometryProcessor* Create() {
         GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gRectEffect, GrRectEffect, ());
         gRectEffect->ref();
         return gRectEffect;
     }
 
     virtual ~GrRectEffect() {}
 
     static const char* Name() { return "RectEdge"; }
 
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
     const GrShaderVar& inRectEdge() const { return fInRectEdge; }
     const GrShaderVar& inWidthHeight() const { return fInWidthHeight; }
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<GrRectEffect>::getInstance();
     }
 
     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
@@ skipping 77 matching lines @@
                                                         GrShaderVar::kAttribute_TypeModifier)))
         , fInWidthHeight(this->addVertexAttrib(
                 GrShaderVar("inWidthHeight",
                             kVec2f_GrSLType,
                             GrShaderVar::kAttribute_TypeModifier))) {
         this->setWillReadFragmentPosition();
     }
 
     virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE { return true; }
 
+    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
+        inout->fValidFlags = 0;
+        inout->fIsSingleComponent = false;
+    }
+
     const GrShaderVar& fInRectEdge;
     const GrShaderVar& fInWidthHeight;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrRectEffect);
@@ skipping 693 matching lines @@
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
 }