Add flipped gradient branch to two point conical gradient

src/effects/gradients/SkGradientShader.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
@@ skipping 185 matching lines @@
     if (fColorCount > 2) {
         Rec* recs = fRecs;
         for (int i = 1; i < fColorCount; i++) {
             buffer.writeInt(recs[i].fPos);
             buffer.writeUInt(recs[i].fScale);
         }
     }
     buffer.writeMatrix(fPtsToUnit);
 }
 
+// V23_COMPATIBILITY_CODE
+void SkGradientShaderBase::flipGradientColors() {
+    SkColor colorsTemp[fColorCount];
+    Rec recsTemp[fColorCount];
+    for (int i = 0; i < fColorCount; ++i) {
+        int offset = fColorCount - i - 1;
+        colorsTemp[i] = fOrigColors[offset];
+        recsTemp[i].fPos = 1 - fRecs[offset].fPos;
+        recsTemp[i].fScale = fRecs[offset].fScale;
+    }
+    memcpy(fOrigColors, colorsTemp, fColorCount * sizeof(SkColor));
+    memcpy(fRecs, recsTemp, fColorCount * sizeof(Rec));
+}
+
 bool SkGradientShaderBase::isOpaque() const {
     return fColorsAreOpaque;
 }
 
 SkGradientShaderBase::GradientShaderBaseContext::GradientShaderBaseContext(
         const SkGradientShaderBase& shader, const SkBitmap& device,
         const SkPaint& paint, const SkMatrix& matrix)
     : INHERITED(shader, device, paint, matrix)
     , fCache(shader.refCache(getPaintAlpha()))
 {
@@ skipping 570 matching lines @@
                                                   int colorCount,
                                                   SkShader::TileMode mode,
                                                   SkUnitMapper* mapper,
                                                   uint32_t flags) {
     if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) {
         return NULL;
     }
     if (start == end && startRadius == endRadius) {
         return SkNEW(SkEmptyShader);
     }
+
     EXPAND_1_COLOR(colorCount);
 
+    bool flipGradient = startRadius > endRadius;
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
-    return SkNEW_ARGS(SkTwoPointConicalGradient,
-                      (start, startRadius, end, endRadius, desc));
+
+    if (!flipGradient) {
+        desc_init(&desc, colors, pos, colorCount, mode, mapper, flags);
+        return SkNEW_ARGS(SkTwoPointConicalGradient,
+                          (start, startRadius, end, endRadius, flipGradient, desc));
+    } else {
+        SkColor colorsNew[colorCount];

[bsalomon, 2014/04/16 19:12:56]

woah.. this looks like a compiler extension. colorCount isn't a compile time
constant.

[mtklein, 2014/04/16 19:20:50]

Yeah, this will be more or less supported depending on the compiler.  It's a C99
feature, and may make it into C++17.  I actually like it, but we can't write it.
 If nothing else, it's safer than alloca...

+        SkScalar posNew[colorCount];
+        for (int i = 0; i < colorCount; ++i) {
+            colorsNew[i] = colors[colorCount - i - 1];
+        }
+
+        if (pos) {
+            for (int i = 0; i < colorCount; ++i) {
+                posNew[i] = 1 - pos[colorCount - i - 1];
+            }
+            desc_init(&desc, colorsNew, posNew, colorCount, mode, mapper, flags);
+        } else {
+            desc_init(&desc, colorsNew, NULL, colorCount, mode, mapper, flags);
+        }
+
+        return SkNEW_ARGS(SkTwoPointConicalGradient,
+                          (end, endRadius, start, startRadius, flipGradient, desc));
+    }
 }
 
 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy,
                                         const SkColor colors[],
                                         const SkScalar pos[],
                                         int colorCount, SkUnitMapper* mapper,
                                         uint32_t flags) {
     if (NULL == colors || colorCount < 1) {
         return NULL;
     }
@@ skipping 330 matching lines @@
             (*stops)[i] = stop;
             stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
     *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
 
     return outColors;
 }
 
 #endif