Return color shader instead of 2-color gradient when color count is 1

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 "Sk4fLinearGradient.h"
 #include "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
@@ skipping 724 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 // Return true if these parameters are valid/legal/safe to construct a gradient
 //
 static bool valid_grad(const SkColor colors[], const SkScalar pos[], int count, unsigned tileMode) {
     return nullptr != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
 }
 
-// assumes colors is SkColor* and pos is SkScalar*
-#define EXPAND_1_COLOR(count)               \
-    SkColor tmp[2];                         \
-    do {                                    \
-        if (1 == count) {                   \
-            tmp[0] = tmp[1] = colors[0];    \
-            colors = tmp;                   \
-            pos = nullptr;                     \
-            count = 2;                      \
-        }                                   \
-    } while (0)
-
 static void desc_init(SkGradientShaderBase::Descriptor* desc,
                       const SkColor colors[], const SkScalar pos[], int colorCount,
                       SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
     SkASSERT(colorCount > 1);
 
     desc->fColors       = colors;
     desc->fPos          = pos;
     desc->fCount        = colorCount;
     desc->fTileMode     = mode;
     desc->fGradFlags    = flags;
     desc->fLocalMatrix  = localMatrix;
 }
 
+// assumes colors is SkColor* and pos is SkScalar*
+#define EXPAND_1_COLOR(count)                \
+     SkColor tmp[2];                         \
+     do {                                    \
+         if (1 == count) {                   \
+             tmp[0] = tmp[1] = colors[0];    \
+             colors = tmp;                   \
+             pos = nullptr;                  \
+             count = 2;                      \
+         }                                   \
+     } while (0)
+
 sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          uint32_t flags,
                                          const SkMatrix* localMatrix) {
     if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
-    EXPAND_1_COLOR(colorCount);
+    if (1 == colorCount) {
+        return SkShader::MakeColorShader(colors[0]);
+    }
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
     return sk_make_sp<SkLinearGradient>(pts, desc);
 }
 
 sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius,
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          uint32_t flags,
                                          const SkMatrix* localMatrix) {
     if (radius <= 0) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
-    EXPAND_1_COLOR(colorCount);
+    if (1 == colorCount) {
+        return SkShader::MakeColorShader(colors[0]);
+    }
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
     return sk_make_sp<SkRadialGradient>(center, radius, desc);
 }
 
 sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start,
                                                   SkScalar startRadius,
                                                   const SkPoint& end,
                                                   SkScalar endRadius,
                                                   const SkColor colors[],
                                                   const SkScalar pos[],
                                                   int colorCount,
                                                   SkShader::TileMode mode,
                                                   uint32_t flags,
                                                   const SkMatrix* localMatrix) {
     if (startRadius < 0 || endRadius < 0) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
     if (startRadius == endRadius) {
         if (start == end || startRadius == 0) {
             return SkShader::MakeEmptyShader();
         }
     }
-
     EXPAND_1_COLOR(colorCount);
 
     bool flipGradient = startRadius > endRadius;
 
     SkGradientShaderBase::Descriptor desc;
 
     if (!flipGradient) {
         desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
         return sk_make_sp<SkTwoPointConicalGradient>(start, startRadius, end, endRadius,
                                                      flipGradient, desc);
@@ skipping 20 matching lines @@
 
 sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy,
                                         const SkColor colors[],
                                         const SkScalar pos[],
                                         int colorCount,
                                         uint32_t flags,
                                         const SkMatrix* localMatrix) {
     if (!valid_grad(colors, pos, colorCount, SkShader::kClamp_TileMode)) {
         return nullptr;
     }
-    EXPAND_1_COLOR(colorCount);
+    if (1 == colorCount) {
+        return SkShader::MakeColorShader(colors[0]);
+    }
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix);
     return sk_make_sp<SkSweepGradient>(cx, cy, desc);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient)
@@ skipping 546 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