Use GradFlags for gradient Flags in SkGradientShader

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"
 #include "SkTwoPointRadialGradient.h"
 #include "SkTwoPointConicalGradient.h"
 #include "SkSweepGradient.h"
 
 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc) {
     SkASSERT(desc.fCount > 1);
 
     fCacheAlpha = 256;  // init to a value that paint.getAlpha() can't return
 
     fMapper = desc.fMapper;
     SkSafeRef(fMapper);
-    fGradFlags = SkToU8(desc.fFlags);
+    fGradFlags = SkToU8(desc.fGradFlags);
 
     SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount);
     SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs));
     fTileMode = desc.fTileMode;
     fTileProc = gTileProcs[desc.fTileMode];
 
     fCache16 = fCache16Storage = NULL;
     fCache32 = NULL;
     fCache32PixelRef = NULL;
 
@@ skipping 722 matching lines @@
             pos = NULL;                     \
             count = 2;                      \
         }                                   \
     } while (0)
 
 static void desc_init(SkGradientShaderBase::Descriptor* desc,
                       const SkColor colors[],
                       const SkScalar pos[], int colorCount,
                       SkShader::TileMode mode,
                       SkUnitMapper* mapper, uint32_t flags) {
-    desc->fColors   = colors;
-    desc->fPos      = pos;
-    desc->fCount    = colorCount;
-    desc->fTileMode = mode;
-    desc->fMapper   = mapper;
-    desc->fFlags    = flags;
+    desc->fColors       = colors;
+    desc->fPos          = pos;
+    desc->fCount        = colorCount;
+    desc->fTileMode     = mode;
+    desc->fMapper       = mapper;
+    desc->fGradFlags    = flags;
 }
 
 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2],
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          SkUnitMapper* mapper,
                                          uint32_t flags) {
     if (NULL == pts || NULL == colors || colorCount < 1) {
         return NULL;
@@ skipping 295 matching lines @@
 
     fIsOpaque = shader.isOpaque();
 
     fColorType = shader.getGpuColorType(&fColors[0]);
 
     // The two and three color specializations do not currently support tiling.
     if (SkGradientShaderBase::kTwo_GpuColorType == fColorType ||
         SkGradientShaderBase::kThree_GpuColorType == fColorType) {
         fRow = -1;
 
-        if (SkGradientShader::kInterpolateColorsInPremul_Flag & shader.getFlags()) {
+        if (SkGradientShader::kInterpolateColorsInPremul_Flag & shader.getGradFlags()) {
             fPremulType = kBeforeInterp_PremulType;
         } else {
             fPremulType = kAfterInterp_PremulType;
         }
         fCoordTransform.reset(kCoordSet, matrix);
     } else {
         // doesn't matter how this is set, just be consistent because it is part of the effect key.
         fPremulType = kBeforeInterp_PremulType;
         SkBitmap bitmap;
         shader.getGradientTableBitmap(&bitmap);
@@ skipping 98 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