Remove the now-unnecessary enum in the elliptical clipping effect.

src/gpu/effects/GrRRectEffect.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 "GrRRectEffect.h"
 
 #include "gl/GrGLEffect.h"
@@ skipping 359 matching lines @@
         fPrevRRect = rrect;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLEllipticalRRectEffect;
 
 class EllipticalRRectEffect : public GrEffect {
 public:
-    // This effect currently works for these two classifications of SkRRects
-    enum RRectType {
-        kSimple_RRectType,       // SkRRect::kSimple_Type
-        kNinePatch_RRectType,    // The two left x radii are the same, the two
-                                 // top y radii are the same, etc.
-    };
-
     // This effect only supports rrects where the radii are >= kRadiusMin.
     static const SkScalar kRadiusMin;
 
-    static GrEffectRef* Create(GrEffectEdgeType, RRectType, const SkRRect&);
+    static GrEffectRef* Create(GrEffectEdgeType, const SkRRect&);
 
     virtual ~EllipticalRRectEffect() {};
     static const char* Name() { return "EllipticalRRect"; }
 
     const SkRRect& getRRect() const { return fRRect; }
 
-    RRectType getRRectType() const { return fRRectType; }
 
     GrEffectEdgeType getEdgeType() const { return fEdgeType; }
 
     typedef GLEllipticalRRectEffect GLEffect;
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
 
 private:
-    EllipticalRRectEffect(GrEffectEdgeType, RRectType, const SkRRect&);
+    EllipticalRRectEffect(GrEffectEdgeType, const SkRRect&);
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
 
     SkRRect             fRRect;
-    RRectType           fRRectType;
     GrEffectEdgeType    fEdgeType;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrEffect INHERITED;
 };
 
 const SkScalar EllipticalRRectEffect::kRadiusMin = 0.5f;
 
-GrEffectRef* EllipticalRRectEffect::Create(GrEffectEdgeType edgeType,
-                                           RRectType rrType,
-                                           const SkRRect& rrect) {
+GrEffectRef* EllipticalRRectEffect::Create(GrEffectEdgeType edgeType, const SkRRect& rrect) {
     SkASSERT(kFillAA_GrEffectEdgeType == edgeType || kInverseFillAA_GrEffectEdgeType == edgeType);
-    return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrType,
-                                                                              rrect))));
+    return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrect))));
 }
 
 void EllipticalRRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
 }
 
 const GrBackendEffectFactory& EllipticalRRectEffect::getFactory() const {
     return GrTBackendEffectFactory<EllipticalRRectEffect>::getInstance();
 }
 
-EllipticalRRectEffect::EllipticalRRectEffect(GrEffectEdgeType edgeType, RRectType rrType,
-                                             const SkRRect& rrect)
+EllipticalRRectEffect::EllipticalRRectEffect(GrEffectEdgeType edgeType, const SkRRect& rrect)
     : fRRect(rrect)
-    , fRRectType(rrType)
     , fEdgeType(edgeType){
     this->setWillReadFragmentPosition();
 }
 
 bool EllipticalRRectEffect::onIsEqual(const GrEffect& other) const {
     const EllipticalRRectEffect& erre = CastEffect<EllipticalRRectEffect>(other);
-    // No need to check fRRectType as it is derived from fRRect.
     return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(EllipticalRRectEffect);
 
 GrEffectRef* EllipticalRRectEffect::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps& caps,
@@ skipping 84 matching lines @@
     // a vector that points straight up for both the TL left and TR corners. Computing an
     // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
     // fragments near the other three edges will get the correct AA. Fragments in the interior of
     // the rrect will have a (0,0) vector at all four corners. So long as the radii > 0.5 they will
     // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
     // The code below is a simplified version of the above that performs maxs on the vector
     // components before computing distances and alpha values so that only one distance computation
     // need be computed to determine the min alpha.
     builder->fsCodeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
     builder->fsCodeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
-    switch (erre.getRRectType()) {
-        case EllipticalRRectEffect::kSimple_RRectType: {
+    switch (erre.getRRect().getType()) {
+        case SkRRect::kSimple_Type: {
             const char *invRadiiXYSqdName;
             fInvRadiiSqdUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                       kVec2f_GrSLType,
                                                       "invRadiiXY",
                                                       &invRadiiXYSqdName);
             builder->fsCodeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
             // Z is the x/y offsets divided by squared radii.
             builder->fsCodeAppendf("\t\tvec2 Z = dxy * %s;\n", invRadiiXYSqdName);
             break;
         }
-        case EllipticalRRectEffect::kNinePatch_RRectType: {
+        case SkRRect::kNinePatch_Type: {
             const char *invRadiiLTRBSqdName;
             fInvRadiiSqdUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                       kVec4f_GrSLType,
                                                       "invRadiiLTRB",
                                                       &invRadiiLTRBSqdName);
             builder->fsCodeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
             // Z is the x/y offsets divided by squared radii. We only care about the (at most) one
             // corner where both the x and y offsets are positive, hence the maxes. (The inverse
             // squared radii will always be positive.)
             builder->fsCodeAppendf("\t\tvec2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);\n",
                                    invRadiiLTRBSqdName, invRadiiLTRBSqdName);
             break;
-       }
+        }
+        default:
+            GrCrash("RRect should always be simple or nine-patch.");
     }
     // implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
     builder->fsCodeAppend("\t\tfloat implicit = dot(Z, dxy) - 1.0;\n");
     // grad_dot is the squared length of the gradient of the implicit.
     builder->fsCodeAppendf("\t\tfloat grad_dot = 4.0 * dot(Z, Z);\n");
     builder->fsCodeAppend("\t\tgrad_dot = max(grad_dot, 1.0e-4);\n");
     builder->fsCodeAppendf("\t\tfloat approx_dist = implicit * inversesqrt(grad_dot);\n");
 
     if (kFillAA_GrEffectEdgeType == erre.getEdgeType()) {
         builder->fsCodeAppend("\t\tfloat alpha = clamp(0.5 - approx_dist, 0.0, 1.0);\n");
     } else {
         builder->fsCodeAppend("\t\tfloat alpha = clamp(0.5 + approx_dist, 0.0, 1.0);\n");
     }
 
     builder->fsCodeAppendf("\t\t%s = %s;\n", outputColor,
                            (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
 }
 
 GrGLEffect::EffectKey GLEllipticalRRectEffect::GenKey(const GrDrawEffect& drawEffect,
                                                       const GrGLCaps&) {
     const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
     GR_STATIC_ASSERT(kLast_GrEffectEdgeType < (1 << 3));
-    return erre.getRRectType() | erre.getEdgeType() << 3;
+    return erre.getRRect().getType() | erre.getEdgeType() << 3;
 }
 
 void GLEllipticalRRectEffect::setData(const GrGLUniformManager& uman,
                                       const GrDrawEffect& drawEffect) {
     const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
     const SkRRect& rrect = erre.getRRect();
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
         SkASSERT(r0.fX >= EllipticalRRectEffect::kRadiusMin);
         SkASSERT(r0.fY >= EllipticalRRectEffect::kRadiusMin);
-        switch (erre.getRRectType()) {
-            case EllipticalRRectEffect::kSimple_RRectType:
+        switch (erre.getRRect().getType()) {
+            case SkRRect::kSimple_Type:
                 rect.inset(r0.fX, r0.fY);
                 uman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
                                                 1.f / (r0.fY * r0.fY));
                 break;
-            case EllipticalRRectEffect::kNinePatch_RRectType: {
+            case SkRRect::kNinePatch_Type: {
                 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
                 SkASSERT(r1.fX >= EllipticalRRectEffect::kRadiusMin);
                 SkASSERT(r1.fY >= EllipticalRRectEffect::kRadiusMin);
                 rect.fLeft += r0.fX;
                 rect.fTop += r0.fY;
                 rect.fRight -= r1.fX;
                 rect.fBottom -= r1.fY;
                 uman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
                                                 1.f / (r0.fY * r0.fY),
                                                 1.f / (r1.fX * r1.fX),
                                                 1.f / (r1.fY * r1.fY));
                 break;
             }
+        default:
+            GrCrash("RRect should always be simple or nine-patch.");
         }
         uman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
         fPrevRRect = rrect;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrEffectRef* GrRRectEffect::Create(GrEffectEdgeType edgeType, const SkRRect& rrect) {
     if (kFillAA_GrEffectEdgeType != edgeType && kInverseFillAA_GrEffectEdgeType != edgeType) {
         return NULL;
     }
     uint32_t cornerFlags;
     if (rrect.isSimple()) {
         if (rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY) {
             if (rrect.getSimpleRadii().fX < CircularRRectEffect::kRadiusMin) {
                 return NULL;
             }
             cornerFlags = CircularRRectEffect::kAll_CornerFlags;
         } else {
             if (rrect.getSimpleRadii().fX < EllipticalRRectEffect::kRadiusMin ||
                 rrect.getSimpleRadii().fY < EllipticalRRectEffect::kRadiusMin) {
                 return NULL;
             }
-            return EllipticalRRectEffect::Create(edgeType,
-                                                 EllipticalRRectEffect::kSimple_RRectType, rrect);
+            return EllipticalRRectEffect::Create(edgeType, rrect);
         }
     } else if (rrect.isComplex() || rrect.isNinePatch()) {
         // Check for the "tab" cases - two adjacent circular corners and two square corners.
         SkScalar radius = 0;
         cornerFlags = 0;
         for (int c = 0; c < 4; ++c) {
             const SkVector& r = rrect.radii((SkRRect::Corner)c);
             SkASSERT((0 == r.fX) == (0 == r.fY));
             if (0 == r.fX) {
                 continue;
@@ skipping 30 matching lines @@
             case CircularRRectEffect::kAll_CornerFlags:
                 break;
             default:
                 if (rrect.isNinePatch()) {
                     const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
                     const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
                     if (r0.fX >= EllipticalRRectEffect::kRadiusMin &&
                         r0.fY >= EllipticalRRectEffect::kRadiusMin &&
                         r1.fX >= EllipticalRRectEffect::kRadiusMin &&
                         r1.fY >= EllipticalRRectEffect::kRadiusMin) {
-                        return EllipticalRRectEffect::Create(edgeType,
-                                                        EllipticalRRectEffect::kNinePatch_RRectType,
-                                                        rrect);
+                        return EllipticalRRectEffect::Create(edgeType, rrect);
                     }
                 }
                 return NULL;
         }
     } else {
         return NULL;
     }
     return CircularRRectEffect::Create(edgeType, cornerFlags, rrect);
 }