Add isSingleComponent bool to getConstantColorComponent

src/gpu/effects/GrConvexPolyEffect.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 "gl/builders/GrGLProgramBuilder.h"
 #include "GrConvexPolyEffect.h"
 
@@ skipping 11 matching lines @@
     typedef GLAARectEffect GLProcessor;
 
     const SkRect& getRect() const { return fRect; }
 
     static const char* Name() { return "AARect"; }
 
     static GrFragmentProcessor* Create(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
         return SkNEW_ARGS(AARectEffect, (edgeType, rect));
     }
 
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        if (fRect.isEmpty()) {
-            // An empty rect will have no coverage anywhere.
-            *color = 0x00000000;
-            *validFlags = kRGBA_GrColorComponentFlags;
-        } else {
-            *validFlags = 0;
-        }
-    }
-
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
 
 private:
     AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect) : fRect(rect), fEdgeType(edgeType) {
         this->setWillReadFragmentPosition();
     }
 
     virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE {
         const AARectEffect& aare = other.cast<AARectEffect>();
         return fRect == aare.fRect;
     }
 
+    virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
+        if (fRect.isEmpty()) {
+            // An empty rect will have no coverage anywhere.
+            inout->fColor = 0x00000000;
+            inout->fValidFlags = kRGBA_GrColorComponentFlags;
+        } else {
+            inout->fValidFlags = 0;
+        }
+        inout->fIsSingleComponent = false;
+    }
+
     SkRect              fRect;
     GrPrimitiveEdgeType fEdgeType;
 
     typedef GrFragmentProcessor INHERITED;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AARectEffect);
@@ skipping 254 matching lines @@
 
 GrFragmentProcessor* GrConvexPolyEffect::Create(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
     if (kHairlineAA_GrProcessorEdgeType == edgeType){
         return NULL;
     }
     return AARectEffect::Create(edgeType, rect);
 }
 
 GrConvexPolyEffect::~GrConvexPolyEffect() {}
 
-void GrConvexPolyEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
-    *validFlags = 0;
+void GrConvexPolyEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
+    inout->fValidFlags = 0;
+    inout->fIsSingleComponent = false;
 }
 
 const GrBackendFragmentProcessorFactory& GrConvexPolyEffect::getFactory() const {
     return GrTBackendFragmentProcessorFactory<GrConvexPolyEffect>::getInstance();
 }
 
 GrConvexPolyEffect::GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[])
     : fEdgeType(edgeType)
     , fEdgeCount(n) {
     // Factory function should have already ensured this.
@@ skipping 29 matching lines @@
     }
 
     GrFragmentProcessor* fp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                         random->nextULessThan(kGrProcessorEdgeTypeCnt));
         fp = GrConvexPolyEffect::Create(edgeType, count, edges);
     } while (NULL == fp);
     return fp;
 }