Get gradient information for gpu effect directly from SkGradientShader instead of calling asAGradie…

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);
 }
 
+void SkGradientShaderBase::getGradientDescriptorGpu(DescriptorGpu* desc) const {
+    desc->fCount = fColorCount;
+    if (fColorCount <= 3) {
+        memcpy(desc->fColors, fOrigColors, fColorCount * sizeof(SkColor));
+    }
+    if (3 == fColorCount){
+        desc->fMidPos = SkFixedToScalar(fRecs[1].fPos);
+    }
+    desc->fTileMode = fTileMode;
+    desc->fFlags = fGradFlags;
+}
+
 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 782 matching lines @@
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GrGradientEffect::GrGradientEffect(GrContext* ctx,
                                    const SkGradientShaderBase& shader,
                                    const SkMatrix& matrix,
                                    SkShader::TileMode tileMode) {
 
     fIsOpaque = shader.isOpaque();
+    SkGradientShaderBase::DescriptorGpu gradDesc;
 
-    SkShader::GradientInfo info;
-    SkScalar pos[3] = {0};
-
-    info.fColorCount = 3;
-    info.fColors = &fColors[0];
-    info.fColorOffsets = &pos[0];
-    shader.asAGradient(&info);
+    gradDesc.fColors = &fColors[0];
+    shader.getGradientDescriptorGpu(&gradDesc);
 
     // The two and three color specializations do not currently support tiling.
     bool foundSpecialCase = false;
-    if (SkShader::kClamp_TileMode == info.fTileMode) {
-        if (2 == info.fColorCount) {
+    if (SkShader::kClamp_TileMode == gradDesc.fTileMode) {
+        if (2 == gradDesc.fCount) {
             fRow = -1; // flag for no atlas
             fColorType = kTwo_ColorType;
             foundSpecialCase = true;
-        } else if (3 == info.fColorCount &&
-                   (SkScalarAbs(pos[1] - SK_ScalarHalf) < SK_Scalar1 / 1000)) { // 3 color symmetric
+        } else if (3 == gradDesc.fCount &&
+                   (SkScalarAbs(gradDesc.fMidPos - SK_ScalarHalf) < SK_Scalar1 / 1000)) { // 3 color symmetric
             fRow = -1; // flag for no atlas
             fColorType = kThree_ColorType;
             foundSpecialCase = true;
         }
     }
     if (foundSpecialCase) {
-        if (SkGradientShader::kInterpolateColorsInPremul_Flag & info.fGradientFlags) {
+        if (SkGradientShader::kInterpolateColorsInPremul_Flag & gradDesc.fFlags) {
             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 99 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