Get gradient information for gpu effect directly from SkGradientShader instead of calling asAGradie…

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
@@ skipping 110 matching lines @@
         kCache32Count   = (1 << kCache32Bits),
         kCache32Shift   = 16 - kCache32Bits,
         kSqrt32Shift    = 8 - kCache32Bits,
 
         /// This value is used to *read* the dither cache; it may be 0
         /// if dithering is disabled.
         kDitherStride32 = kCache32Count,
         kDitherStride16 = kCache16Count,
     };
 
+    enum GpuColorType {
+        kTwo_GpuColorType,
+        kThree_GpuColorType, // Symmetric three color
+        kTexture_GpuColorType
+    };
+
+    // Determines and returns the gradient is a two color gradient, symmetric three color gradient
+    // or other (texture gradient). If it is two or symmetric three color, the colors array will
+    // also be filled with the gradient colors
+    GpuColorType getGpuColorType(SkColor colors[3]) const;
+
+    uint32_t getFlags() const { return fGradFlags; } 

[Dominik Grewe, 2014/04/22 10:19:33]

I don't think getFlags is a good name if we already have a virtual (non-const)
getFlags  above. Maybe getGradientFlags was better?

[bsalomon, 2014/04/22 13:14:51]

Good point... I didn't notice the other getFlags().  

 
 protected:
     SkGradientShaderBase(SkReadBuffer& );
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     SK_TO_STRING_OVERRIDE()
 
     SkUnitMapper* fMapper;
     SkMatrix    fPtsToUnit;     // set by subclass
     SkMatrix    fDstToIndex;
     SkMatrix::MapXYProc fDstToIndexProc;
@@ skipping 103 matching lines @@
                      const SkMatrix& matrix,
                      SkShader::TileMode tileMode);
 
     virtual ~GrGradientEffect();
 
     bool useAtlas() const { return SkToBool(-1 != fRow); }
     SkScalar getYCoord() const { return fYCoord; };
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
-    enum ColorType {
-        kTwo_ColorType,
-        kThree_ColorType,
-        kTexture_ColorType
-    };
-
-    ColorType getColorType() const { return fColorType; }
+    SkGradientShaderBase::GpuColorType getColorType() const { return fColorType; }
 
     enum PremulType {
         kBeforeInterp_PremulType,
         kAfterInterp_PremulType,
     };
 
     PremulType getPremulType() const { return fPremulType; }
 
     const SkColor* getColors(int pos) const {
-        SkASSERT(fColorType != kTexture_ColorType);
+        SkASSERT(fColorType != SkGradientShaderBase::kTexture_GpuColorType);
         SkASSERT((pos-1) <= fColorType);
         return &fColors[pos];
     }
 
 protected:
 
     /** Populates a pair of arrays with colors and stop info to construct a random gradient.
         The function decides whether stop values should be used or not. The return value indicates
         the number of colors, which will be capped by kMaxRandomGradientColors. colors should be
         sized to be at least kMaxRandomGradientColors. stops is a pointer to an array of at least
         size kMaxRandomGradientColors. It may be updated to NULL, indicating that NULL should be
         passed to the gradient factory rather than the array.
     */
     static const int kMaxRandomGradientColors = 4;
     static int RandomGradientParams(SkRandom* r,
                                     SkColor colors[kMaxRandomGradientColors],
                                     SkScalar** stops,
                                     SkShader::TileMode* tm);
 
     virtual bool onIsEqual(const GrEffect& effect) const SK_OVERRIDE;
 
     const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
 
 private:
     static const GrCoordSet kCoordSet = kLocal_GrCoordSet;
 
-    enum {
-        kMaxAnalyticColors = 3 // if more colors use texture
-    };
-
     GrCoordTransform fCoordTransform;
     GrTextureAccess fTextureAccess;
     SkScalar fYCoord;
     GrTextureStripAtlas* fAtlas;
     int fRow;
     bool fIsOpaque;
-    ColorType fColorType;
-    SkColor fColors[kMaxAnalyticColors];
+    SkGradientShaderBase::GpuColorType fColorType;
+    SkColor fColors[3]; // More than 3 colors we use texture
     PremulType fPremulType; // This only changes behavior for two and three color special cases.
                             // It is already baked into to the table for texture gradients.
     typedef GrEffect INHERITED;
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Base class for GL gradient effects
 class GrGLGradientEffect : public GrGLEffect {
@@ skipping 12 matching lines @@
         kTwoColorKey = 2 << kPremulTypeKeyBitCnt,
         kThreeColorKey = 3 << kPremulTypeKeyBitCnt,
         kColorKeyMask = kTwoColorKey | kThreeColorKey,
         kColorKeyBitCnt = 2,
 
         // Subclasses must shift any key bits they produce up by this amount
         // and combine with the result of GenBaseGradientKey.
         kBaseKeyBitCnt = (kPremulTypeKeyBitCnt + kColorKeyBitCnt)
     };
 
-    static GrGradientEffect::ColorType ColorTypeFromKey(EffectKey key){
+    static SkGradientShaderBase::GpuColorType ColorTypeFromKey(EffectKey key){
         if (kTwoColorKey == (key & kColorKeyMask)) {
-            return GrGradientEffect::kTwo_ColorType;
+            return SkGradientShaderBase::kTwo_GpuColorType;
         } else if (kThreeColorKey == (key & kColorKeyMask)) {
-            return GrGradientEffect::kThree_ColorType;
-        } else {return GrGradientEffect::kTexture_ColorType;}
+            return SkGradientShaderBase::kThree_GpuColorType;
+        } else {return SkGradientShaderBase::kTexture_GpuColorType;}
     }
 
     static GrGradientEffect::PremulType PremulTypeFromKey(EffectKey key){
         if (kPremulBeforeInterpKey == (key & kPremulTypeMask)) {
             return GrGradientEffect::kBeforeInterp_PremulType;
         } else {
             return GrGradientEffect::kAfterInterp_PremulType;
         }
     }
 
@@ skipping 24 matching lines @@
     GrGLUniformManager::UniformHandle fColorStartUni;
     GrGLUniformManager::UniformHandle fColorMidUni;
     GrGLUniformManager::UniformHandle fColorEndUni;
 
     typedef GrGLEffect INHERITED;
 };
 
 #endif
 
 #endif