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 103 matching lines @@
                 prev = curr;
                 recs += 1;
             }
         } else {    // assume even distribution
             SkFixed dp = SK_Fixed1 / (desc.fCount - 1);
             SkFixed p = dp;
             SkFixed scale = (desc.fCount - 1) << 8;  // (1 << 24) / dp
             for (int i = 1; i < desc.fCount; i++) {
                 recs->fPos   = p;
                 recs->fScale = scale;
+                if (i == desc.fCount - 1) {
+                    recs->fPos = SK_Fixed1;
+                }
                 recs += 1;
                 p += dp;
             }
         }
     }
     this->initCommon();
 }
 
 static uint32_t pack_mode_flags(SkShader::TileMode mode, uint32_t flags) {
     SkASSERT(0 == (flags >> 28));
@@ skipping 96 matching lines @@
             return kTwo_GpuColorType;
         } else if (3 == fColorCount &&
                    (SkScalarAbs(
                     SkFixedToScalar(fRecs[1].fPos) - SK_ScalarHalf) < SK_Scalar1 / 1000)) {
             return kThree_GpuColorType;
         }
     }
     return kTexture_GpuColorType;
 }
 
+void SkGradientShaderBase::FlipGradientColors(SkColor* colorDst, Rec* recDst,
+                                              SkColor* colorSrc, Rec* recSrc,
+                                              int count) {
+    SkAutoSTArray<8, SkColor> colorsTemp(count);
+    for (int i = 0; i < count; ++i) {
+        int offset = count - i - 1;
+        colorsTemp[i] = colorSrc[offset];
+    }
+    if (count > 2) {
+        SkAutoSTArray<8, Rec> recsTemp(count);
+        for (int i = 0; i < count; ++i) {
+            int offset = count - i - 1;
+            recsTemp[i].fPos = SK_Fixed1 - recSrc[offset].fPos;
+            recsTemp[i].fScale = recSrc[offset].fScale;
+        }
+        memcpy(recDst, recsTemp.get(), count * sizeof(Rec));
+    }
+    memcpy(colorDst, colorsTemp.get(), count * sizeof(SkColor));
+}
+
+void SkGradientShaderBase::flipGradientColors() {
+    FlipGradientColors(fOrigColors, fRecs, fOrigColors, fRecs, fColorCount); 
+}
+/*
 // V23_COMPATIBILITY_CODE
 void SkGradientShaderBase::flipGradientColors() {
     SkAutoSTArray<8, SkColor> colorsTemp(fColorCount);
     for (int i = 0; i < fColorCount; ++i) {
         int offset = fColorCount - i - 1;
         colorsTemp[i] = fOrigColors[offset];
     }
     if (fColorCount > 2) {
         SkAutoSTArray<8, Rec> recsTemp(fColorCount);
         for (int i = 0; i < fColorCount; ++i) {
             int offset = fColorCount - i - 1;
             recsTemp[i].fPos = 1 - fRecs[offset].fPos;
             recsTemp[i].fScale = fRecs[offset].fScale;
         }
         memcpy(fRecs, recsTemp.get(), fColorCount * sizeof(Rec));
     }
     memcpy(fOrigColors, colorsTemp.get(), fColorCount * sizeof(SkColor));
 }
+*/
 
 bool SkGradientShaderBase::isOpaque() const {
     return fColorsAreOpaque;
 }
 
 bool SkGradientShaderBase::setContext(const SkBitmap& device,
                                  const SkPaint& paint,
                                  const SkMatrix& matrix) {
     if (!this->INHERITED::setContext(device, paint, matrix)) {
         return false;
@@ skipping 387 matching lines @@
     if (!gCache->find(storage.get(), size, bitmap)) {
         // force our cahce32pixelref to be built
         (void)this->getCache32();
         bitmap->setConfig(SkImageInfo::MakeN32Premul(kCache32Count, 1));
         bitmap->setPixelRef(fCache32PixelRef);
 
         gCache->add(storage.get(), size, *bitmap);
     }
 }
 
-void SkGradientShaderBase::commonAsAGradient(GradientInfo* info) const {
+void SkGradientShaderBase::commonAsAGradient(GradientInfo* info, bool flipGrad) const {
     if (info) {
         if (info->fColorCount >= fColorCount) {
+            SkColor* colorLoc;
+            Rec*     recLoc;
+            if (flipGrad && (info->fColors || info->fColorOffsets)) {
+                SkAutoSTArray<8, SkColor> colorStorage(fColorCount);
+                SkAutoSTArray<8, Rec> recStorage(fColorCount);
+                colorLoc = colorStorage.get();
+                recLoc = recStorage.get();
+                FlipGradientColors(colorLoc, recLoc, fOrigColors, fRecs, fColorCount);
+            } else {
+                colorLoc = fOrigColors;
+                recLoc = fRecs;
+            }
             if (info->fColors) {
-                memcpy(info->fColors, fOrigColors, fColorCount * sizeof(SkColor));
+                    memcpy(info->fColors, colorLoc, fColorCount * sizeof(SkColor));
             }
             if (info->fColorOffsets) {
                 if (fColorCount == 2) {
                     info->fColorOffsets[0] = 0;
                     info->fColorOffsets[1] = SK_Scalar1;
                 } else if (fColorCount > 2) {
                     for (int i = 0; i < fColorCount; ++i) {
-                        info->fColorOffsets[i] = SkFixedToScalar(fRecs[i].fPos);
+                        info->fColorOffsets[i] = SkFixedToScalar(recLoc[i].fPos);
                     }
                 }
             }
         }
         info->fColorCount = fColorCount;
         info->fTileMode = fTileMode;
         info->fGradientFlags = fGradFlags;
     }
 }
 
@@ skipping 488 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