remove redundant/deprecated TwoPointRadial gradiet -- use TwoPointConical

This CL derived from https://codereview.chromium.org/1114243005/

BUG=skia:

Review URL: https://codereview.chromium.org/1117423003

bench/GradientBench.cpp

@@ -71,20 +71,6 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
                                          data.fPos, data.fCount);
 }
 
-/// Ignores scale
-static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, float scale) {
-    SkPoint center0, center1;
-    center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
-                SkScalarAve(pts[0].fY, pts[1].fY));
-    center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
-                SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
-                                                  center1, (pts[1].fX - pts[0].fX) / 7,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm);
-}
-
 /// Ignores scale
 static SkShader* MakeConical(const SkPoint pts[2], const GradData& data,
                              SkShader::TileMode tm, float scale) {
@@ -149,7 +135,6 @@ static const struct {
     { MakeLinear,                 "linear"  },
     { MakeRadial,                 "radial1" },
     { MakeSweep,                  "sweep"   },
-    { Make2Radial,                "radial2" },
     { MakeConical,                "conical" },
     { MakeConicalZeroRad,         "conicalZero" },
     { MakeConicalOutside,         "conicalOut" },
@@ -160,7 +145,6 @@ enum GradType { // these must match the order in gGrads
     kLinear_GradType,
     kRadial_GradType,
     kSweep_GradType,
-    kRadial2_GradType,
     kConical_GradType,
     kConicalZero_GradType,
     kConicalOut_GradType,
@@ -313,9 +297,6 @@ DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kR
 DEF_BENCH( return new GradientBench(kSweep_GradType); )
 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[2]); )
-DEF_BENCH( return new GradientBench(kRadial2_GradType); )
-DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[1]); )
-DEF_BENCH( return new GradientBench(kRadial2_GradType, gGradData[0], SkShader::kMirror_TileMode); )
 DEF_BENCH( return new GradientBench(kConical_GradType); )
 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[2]); )

gm/blurrect.cpp

@@ -74,7 +74,7 @@ static SkShader* MakeRadial() {
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(center1, (pts[1].fX - pts[0].fX) / 7,
+    return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                   center0, (pts[1].fX - pts[0].fX) / 2,
                                                   colors, pos, SK_ARRAY_COUNT(colors), tm,
                                                   0, &scale);

gm/blurroundrect.cpp

@@ -112,10 +112,10 @@ static SkShader* MakeRadial() {
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(center1, (pts[1].fX - pts[0].fX) / 7,
+    return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  colors, pos, SK_ARRAY_COUNT(colors), tm,
+                                                   colors, pos, SK_ARRAY_COUNT(colors), tm,
-                                                  0, &scale);
+                                                   0, &scale);
 }
 
 // Simpler blurred RR test cases where all the radii are the same.

gm/gradients.cpp

@@ -70,11 +70,11 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
-                                                  center1, (pts[1].fX - pts[0].fX) / 7,
+                                                   center1, (pts[1].fX - pts[0].fX) / 7,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm,
+                                                   data.fColors, data.fPos, data.fCount, tm,
-                                                  0, &localMatrix);
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
@@ -273,9 +273,9 @@ protected:
         SkPoint c1;
         c1.iset(0, 25);
         SkScalar r1 = SkIntToScalar(150);
-        SkShader* s = SkGradientShader::CreateTwoPointRadial(c0, r0, c1, r1, colors,
+        SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
-                                                             pos, SK_ARRAY_COUNT(pos),
+                                                              pos, SK_ARRAY_COUNT(pos),
-                                                             SkShader::kClamp_TileMode);
+                                                              SkShader::kClamp_TileMode);
         SkPaint paint;
         paint.setShader(s)->unref();
         canvas->drawPaint(paint);

gm/gradients_no_texture.cpp

@@ -51,7 +51,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
         center1, (pts[1].fX - pts[0].fX) / 7,
         center0, (pts[1].fX - pts[0].fX) / 2,
         data.fColors, data.fPos, data.fCount, tm);

gm/shadertext.cpp

@@ -64,13 +64,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader:
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
                             center1, (pts[1].fX - pts[0].fX) / 7,
                             center0, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
@@ -79,7 +79,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
-    MakeLinear, MakeRadial, MakeSweep, Make2Radial
+    MakeLinear, MakeRadial, MakeSweep, Make2Conical
 };
 
 ///////////////////////////////////////////////////////////////////////////////

gm/twopointradial.cpp

@@ -1,112 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "gm.h"
-#include "SkCanvas.h"
-#include "SkPaint.h"
-#include "SkGradientShader.h"
-
-static void intToScalars(SkScalar dst[], const int src[], int n) {
-    for (int i = 0; i < n; ++i) {
-        dst[i] = SkIntToScalar(src[i]);
-    }
-}
-
-static void drawGrad(SkCanvas* canvas, const SkScalar d0[], const SkScalar d1[]) {
-    const SkRect bounds = SkRect::MakeXYWH(SkIntToScalar(-50),
-                                           SkIntToScalar(-50),
-                                           SkIntToScalar(200),
-                                           SkIntToScalar(100));
-
-    SkPoint c0 = { d0[0], d0[1] };
-    SkScalar r0 = d0[2];
-    SkPoint c1 = { d1[0], d1[1] };
-    SkScalar r1 = d1[2];
-
-    SkColor colors[] = { SK_ColorGREEN, SK_ColorRED };
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    sk_tool_utils::set_portable_typeface(&paint);
-
-    SkString str;
-    str.printf("%g,%g,%g  %g,%g,%g",
-               SkScalarToFloat(c0.fX), SkScalarToFloat(c0.fY), SkScalarToFloat(r0),
-               SkScalarToFloat(c1.fX), SkScalarToFloat(c1.fY), SkScalarToFloat(r1));
-    canvas->drawText(str.c_str(), str.size(),
-                     bounds.fLeft, bounds.fTop - paint.getTextSize()/2, paint);
-
-    paint.setShader(SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1,
-                                                            colors, NULL, 2,
-                                                            SkShader::kClamp_TileMode))->unref();
-    canvas->drawRect(bounds, paint);
-
-    paint.setShader(NULL);
-    paint.setColor(0x66000000);
-    paint.setStyle(SkPaint::kStroke_Style);
-    canvas->drawCircle(c0.fX, c0.fY, r0, paint);
-    canvas->drawCircle(c1.fX, c1.fY, r1, paint);
-    canvas->drawRect(bounds, paint);
-}
-
-class TwoPointRadialGM : public skiagm::GM {
-public:
-    TwoPointRadialGM() {}
-
-protected:
-    SkString onShortName() {
-        return SkString("twopointconical");
-    }
-
-    SkISize onISize() { return SkISize::Make(480, 780); }
-
-    virtual void onDraw(SkCanvas* canvas) {
-        if (false) {
-            SkPaint paint;
-            paint.setColor(SK_ColorBLUE);
-            canvas->drawRect(
-                    SkRect::MakeWH(SkIntToScalar(this->getISize().fWidth),
-                                   SkIntToScalar(this->getISize().fHeight)),
-                    paint);
-        }
-        SkPaint paint;
-        const int R0 = 20;
-        const int R1 = 40;
-
-        const SkScalar DX = SkIntToScalar(250);
-        const SkScalar DY = SkIntToScalar(130);
-
-        canvas->translate(SkIntToScalar(60), SkIntToScalar(70));
-
-        static const int gData[] = {
-            0, 0, R0,       0, 0, R1,
-            0, 0, R0,       20, 0, R1,
-            0, 0, R0,       25, 0, R1,
-            0, 0, R0,       100, 0, R1,
-            0, 0, R0,       25, 0, R0,
-            0, 0, R0,       100, 0, R0,
-        };
-
-        int count = SK_ARRAY_COUNT(gData) / 6;
-        for (int i = 0; i < count; ++i) {
-            SkScalar data[6];
-            intToScalars(data, &gData[i * 6], 6);
-
-            int n = canvas->save();
-            drawGrad(canvas, &data[0], &data[3]);
-            canvas->translate(DX, 0);
-            drawGrad(canvas, &data[3], &data[0]);
-            canvas->restoreToCount(n);
-            canvas->translate(0, DY);
-        }
-    }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-static skiagm::GM* F(void*) { return new TwoPointRadialGM; }
-
-static skiagm::GMRegistry gR(F);

gyp/effects.gypi

@@ -74,8 +74,6 @@
     '<(skia_src_path)/effects/gradients/SkLinearGradient.h',
     '<(skia_src_path)/effects/gradients/SkRadialGradient.cpp',
     '<(skia_src_path)/effects/gradients/SkRadialGradient.h',
-    '<(skia_src_path)/effects/gradients/SkTwoPointRadialGradient.cpp',
-    '<(skia_src_path)/effects/gradients/SkTwoPointRadialGradient.h',
     '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient.cpp',
     '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient.h',
     '<(skia_src_path)/effects/gradients/SkTwoPointConicalGradient_gpu.cpp',

gyp/gmslides.gypi

@@ -229,7 +229,6 @@
         '../gm/tilemodes_scaled.cpp',
         '../gm/tinybitmap.cpp',
         '../gm/transparency.cpp',
-        '../gm/twopointradial.cpp',
         '../gm/typeface.cpp',
         '../gm/vertices.cpp',
         '../gm/verttext.cpp',

include/core/SkShader.h

@@ -246,19 +246,6 @@ public:
                             //   to (0,0) as bitmap x coord, where angle = 0 is
                             //   bitmap left edge of bitmap = 2pi is the
                             //   right edge. Bitmap is 1 pixel tall. No extras
-        kTwoPointRadial_BitmapType,
-                            //<! Matrix transforms to space where (0,0) is
-                            //   the center of the starting circle.  The second
-                            //   circle will be centered (x, 0) where x  may be
-                            //   0. The post-matrix space is normalized such
-                            //   that 1 is the second radius - first radius.
-                            //   Three extra parameters are returned:
-                            //      0: x-offset of second circle center
-                            //         to first.
-                            //      1: radius of first circle in post-matrix
-                            //         space
-                            //      2: the second radius minus the first radius
-                            //         in pre-transformed space.
         kTwoPointConical_BitmapType,
                             //<! Matrix transforms to space where (0,0) is
                             //   the center of the starting circle.  The second
@@ -314,7 +301,7 @@ public:
      *      fPoint[0] and fPoint[1] are the end-points of the gradient
      *  Radial:
      *      fPoint[0] and fRadius[0] are the center and radius
-     *  Radial2:
+     *  Conical:
      *      fPoint[0] and fRadius[0] are the center and radius of the 1st circle
      *      fPoint[1] and fRadius[1] are the center and radius of the 2nd circle
      *  Sweep:
@@ -326,7 +313,6 @@ public:
         kColor_GradientType,
         kLinear_GradientType,
         kRadial_GradientType,
-        kRadial2_GradientType,
         kSweep_GradientType,
         kConical_GradientType,
         kLast_GradientType = kConical_GradientType

include/effects/SkGradientShader.h

@@ -80,39 +80,6 @@ public:
         return CreateRadial(center, radius, colors, pos, count, mode, 0, NULL);
     }
 
-    /** Returns a shader that generates a radial gradient given the start position, start radius, end position and end radius.
-        <p />
-        CreateTwoPointRadial returns a shader with a reference count of 1.
-        The caller should decrement the shader's reference count when done with the shader.
-        It is an error for colorCount to be < 2, for startRadius or endRadius to be < 0, or for
-        startRadius to be equal to endRadius.
-        @param  start   The center of the start circle for this gradient
-        @param  startRadius  Must be positive.  The radius of the start circle for this gradient.
-        @param  end     The center of the end circle for this gradient
-        @param  endRadius  Must be positive. The radius of the end circle for this gradient.
-        @param  colors  The array[count] of colors, to be distributed between the center and edge of the circle
-        @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
-                        each corresponding color in the colors array. If this is NULL,
-                        the the colors are distributed evenly between the center and edge of the circle.
-                        If this is not null, the values must begin with 0, end with 1.0, and
-                        intermediate values must be strictly increasing.
-        @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
-        @param  mode    The tiling mode
-    */
-    static SkShader* CreateTwoPointRadial(const SkPoint& start, SkScalar startRadius,
-                                          const SkPoint& end, SkScalar endRadius,
-                                          const SkColor colors[], const SkScalar pos[], int count,
-                                          SkShader::TileMode mode,
-                                          uint32_t flags, const SkMatrix* localMatrix);
-
-    static SkShader* CreateTwoPointRadial(const SkPoint& start, SkScalar startRadius,
-                                          const SkPoint& end, SkScalar endRadius,
-                                          const SkColor colors[], const SkScalar pos[], int count,
-                                          SkShader::TileMode mode) {
-        return CreateTwoPointRadial(start, startRadius, end, endRadius, colors, pos, count, mode,
-                                    0, NULL);
-    }
-
     /**
      *  Returns a shader that generates a conical gradient given two circles, or
      *  returns NULL if the inputs are invalid. The gradient interprets the

samplecode/Sample2PtRadial.cpp

@@ -11,15 +11,15 @@
 #include "SkGradientShader.h"
 
 
-class TwoPtRadialView : public SampleView {
+class TwoPtConicalView : public SampleView {
 public:
-    TwoPtRadialView() {}
+    TwoPtConicalView() {}
 
 protected:
     // overrides from SkEventSink
     virtual bool onQuery(SkEvent* evt) {
         if (SampleCode::TitleQ(*evt)) {
-            SampleCode::TitleR(evt, "2PtRadial");
+            SampleCode::TitleR(evt, "2PtConical");
             return true;
         }
         return this->INHERITED::onQuery(evt);
@@ -33,7 +33,7 @@ protected:
         SkScalar r0 = 100;
         SkPoint c1 = { 100, 100 };
         SkScalar r1 = 100;
-        SkShader* s = SkGradientShader::CreateTwoPointRadial(c0, r0, c1, r1, colors,
+        SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
                                                              NULL, 2,
                                                              SkShader::kClamp_TileMode);
 
@@ -48,5 +48,5 @@ private:
 
 //////////////////////////////////////////////////////////////////////////////
 
-static SkView* MyFactory() { return new TwoPtRadialView; }
+static SkView* MyFactory() { return new TwoPtConicalView; }
 static SkViewRegister reg(MyFactory);

samplecode/SampleGradients.cpp

@@ -82,24 +82,24 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader:
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
                             center1, (pts[1].fX - pts[0].fX) / 7,
                             center0, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
 }
 
-static SkShader* Make2RadialConcentric(const SkPoint pts[2], const GradData& data,
+static SkShader* Make2ConicalConcentric(const SkPoint pts[2], const GradData& data,
                                        SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
                             center, (pts[1].fX - pts[0].fX) / 7,
                             center, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
@@ -108,7 +108,7 @@ static SkShader* Make2RadialConcentric(const SkPoint pts[2], const GradData& dat
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
-    MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2RadialConcentric
+    MakeLinear, MakeRadial, MakeSweep, Make2Conical, Make2ConicalConcentric
 };
 
 ///////////////////////////////////////////////////////////////////////////////

samplecode/SampleShaderText.cpp

@@ -72,13 +72,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader:
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
                             center1, (pts[1].fX - pts[0].fX) / 7,
                             center0, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
@@ -87,7 +87,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
-    MakeLinear, MakeRadial, MakeSweep, Make2Radial
+    MakeLinear, MakeRadial, MakeSweep, Make2Conical
 };
 
 ///////////////////////////////////////////////////////////////////////////////

samplecode/SampleSlides.cpp

@@ -197,13 +197,13 @@ static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader:
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointRadial(
+    return SkGradientShader::CreateTwoPointConical(
                                                   center1, (pts[1].fX - pts[0].fX) / 7,
                                                   center0, (pts[1].fX - pts[0].fX) / 2,
                                                   data.fColors, data.fPos, data.fCount, tm);
@@ -211,7 +211,7 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, SkShade
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 static const GradMaker gGradMakers[] = {
-    MakeLinear, MakeRadial, MakeSweep, Make2Radial
+    MakeLinear, MakeRadial, MakeSweep, Make2Conical
 };
 
 static void gradient_slide(SkCanvas* canvas) {

src/device/xps/SkXPSDevice.cpp

@@ -1044,8 +1044,7 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint,
             return S_OK;
         }
 
-        if (SkShader::kRadial2_GradientType == gradientType ||
+        if (SkShader::kConical_GradientType == gradientType) {
-            SkShader::kConical_GradientType == gradientType) {
             //simple if affine and one is 0, otherwise will have to fake
         }
 
@@ -1061,8 +1060,6 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint,
                                                         &outMatrix,
                                                         xy);
     switch (bitmapType) {
-        case SkShader::kNone_BitmapType:
-            break;
         case SkShader::kDefault_BitmapType: {
             //TODO: outMatrix??
             SkMatrix localMatrix = shader->getLocalMatrix();
@@ -1081,9 +1078,6 @@ HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint,
 
             return S_OK;
         }
-        case SkShader::kRadial_BitmapType:
-        case SkShader::kSweep_BitmapType:
-        case SkShader::kTwoPointRadial_BitmapType:
         default:
             break;
     }

src/effects/gradients/SkGradientShader.cpp

@@ -8,7 +8,6 @@
 #include "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
-#include "SkTwoPointRadialGradient.h"
 #include "SkTwoPointConicalGradient.h"
 #include "SkSweepGradient.h"
 
@@ -802,30 +801,6 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
     return SkNEW_ARGS(SkRadialGradient, (center, radius, desc));
 }
 
-SkShader* SkGradientShader::CreateTwoPointRadial(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 NULL;
-    }
-    if (!valid_grad(colors, pos, colorCount, mode)) {
-        return NULL;
-    }
-    EXPAND_1_COLOR(colorCount);
-
-    SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
-    return SkNEW_ARGS(SkTwoPointRadialGradient,
-                      (start, startRadius, end, endRadius, desc));
-}
-
 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
                                                   SkScalar startRadius,
                                                   const SkPoint& end,
@@ -897,7 +872,6 @@ 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)
-    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 

src/effects/gradients/SkTwoPointRadialGradient.cpp

@@ -1,724 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkTwoPointRadialGradient.h"
-
-/* Two-point radial gradients are specified by two circles, each with a center
-   point and radius.  The gradient can be considered to be a series of
-   concentric circles, with the color interpolated from the start circle
-   (at t=0) to the end circle (at t=1).
-
-   For each point (x, y) in the span, we want to find the
-   interpolated circle that intersects that point.  The center
-   of the desired circle (Cx, Cy) falls at some distance t
-   along the line segment between the start point (Sx, Sy) and
-   end point (Ex, Ey):
-
-      Cx = (1 - t) * Sx + t * Ex        (0 <= t <= 1)
-      Cy = (1 - t) * Sy + t * Ey
-
-   The radius of the desired circle (r) is also a linear interpolation t
-   between the start and end radii (Sr and Er):
-
-      r = (1 - t) * Sr + t * Er
-
-   But
-
-      (x - Cx)^2 + (y - Cy)^2 = r^2
-
-   so
-
-     (x - ((1 - t) * Sx + t * Ex))^2
-   + (y - ((1 - t) * Sy + t * Ey))^2
-   = ((1 - t) * Sr + t * Er)^2
-
-   Solving for t yields
-
-     [(Sx - Ex)^2 + (Sy - Ey)^2 - (Er - Sr)^2)] * t^2
-   + [2 * (Sx - Ex)(x - Sx) + 2 * (Sy - Ey)(y - Sy) - 2 * (Er - Sr) * Sr] * t
-   + [(x - Sx)^2 + (y - Sy)^2 - Sr^2] = 0
-
-   To simplify, let Dx = Sx - Ex, Dy = Sy - Ey, Dr = Er - Sr, dx = x - Sx, dy = y - Sy
-
-     [Dx^2 + Dy^2 - Dr^2)] * t^2
-   + 2 * [Dx * dx + Dy * dy - Dr * Sr] * t
-   + [dx^2 + dy^2 - Sr^2] = 0
-
-   A quadratic in t.  The two roots of the quadratic reflect the two
-   possible circles on which the point may fall.  Solving for t yields
-   the gradient value to use.
-
-   If a<0, the start circle is entirely contained in the
-   end circle, and one of the roots will be <0 or >1 (off the line
-   segment).  If a>0, the start circle falls at least partially
-   outside the end circle (or vice versa), and the gradient
-   defines a "tube" where a point may be on one circle (on the
-   inside of the tube) or the other (outside of the tube).  We choose
-   one arbitrarily.
-
-   In order to keep the math to within the limits of fixed point,
-   we divide the entire quadratic by Dr^2, and replace
-   (x - Sx)/Dr with x' and (y - Sy)/Dr with y', giving
-
-   [Dx^2 / Dr^2 + Dy^2 / Dr^2 - 1)] * t^2
-   + 2 * [x' * Dx / Dr + y' * Dy / Dr - Sr / Dr] * t
-   + [x'^2 + y'^2 - Sr^2/Dr^2] = 0
-
-   (x' and y' are computed by appending the subtract and scale to the
-   fDstToIndex matrix in the constructor).
-
-   Since the 'A' component of the quadratic is independent of x' and y', it
-   is precomputed in the constructor.  Since the 'B' component is linear in
-   x' and y', if x and y are linear in the span, 'B' can be computed
-   incrementally with a simple delta (db below).  If it is not (e.g.,
-   a perspective projection), it must be computed in the loop.
-
-*/
-
-namespace {
-
-inline SkFixed two_point_radial(SkScalar b, SkScalar fx, SkScalar fy,
-                                SkScalar sr2d2, SkScalar foura,
-                                SkScalar oneOverTwoA, bool posRoot) {
-    SkScalar c = SkScalarSquare(fx) + SkScalarSquare(fy) - sr2d2;
-    if (0 == foura) {
-        return SkScalarToFixed(SkScalarDiv(-c, b));
-    }
-
-    SkScalar discrim = SkScalarSquare(b) - SkScalarMul(foura, c);
-    if (discrim < 0) {
-        discrim = -discrim;
-    }
-    SkScalar rootDiscrim = SkScalarSqrt(discrim);
-    SkScalar result;
-    if (posRoot) {
-        result = SkScalarMul(-b + rootDiscrim, oneOverTwoA);
-    } else {
-        result = SkScalarMul(-b - rootDiscrim, oneOverTwoA);
-    }
-    return SkScalarToFixed(result);
-}
-
-typedef void (* TwoPointRadialShadeProc)(SkScalar fx, SkScalar dx,
-        SkScalar fy, SkScalar dy,
-        SkScalar b, SkScalar db,
-        SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot,
-        SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
-        int count);
-
-void shadeSpan_twopoint_clamp(SkScalar fx, SkScalar dx,
-        SkScalar fy, SkScalar dy,
-        SkScalar b, SkScalar db,
-        SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot,
-        SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
-        int count) {
-    for (; count > 0; --count) {
-        SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura,
-                                     fOneOverTwoA, posRoot);
-        SkFixed index = SkClampMax(t, 0xFFFF);
-        SkASSERT(index <= 0xFFFF);
-        *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift];
-        fx += dx;
-        fy += dy;
-        b += db;
-    }
-}
-void shadeSpan_twopoint_mirror(SkScalar fx, SkScalar dx,
-        SkScalar fy, SkScalar dy,
-        SkScalar b, SkScalar db,
-        SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot,
-        SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
-        int count) {
-    for (; count > 0; --count) {
-        SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura,
-                                     fOneOverTwoA, posRoot);
-        SkFixed index = mirror_tileproc(t);
-        SkASSERT(index <= 0xFFFF);
-        *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift];
-        fx += dx;
-        fy += dy;
-        b += db;
-    }
-}
-
-void shadeSpan_twopoint_repeat(SkScalar fx, SkScalar dx,
-        SkScalar fy, SkScalar dy,
-        SkScalar b, SkScalar db,
-        SkScalar fSr2D2, SkScalar foura, SkScalar fOneOverTwoA, bool posRoot,
-        SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
-        int count) {
-    for (; count > 0; --count) {
-        SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura,
-                                     fOneOverTwoA, posRoot);
-        SkFixed index = repeat_tileproc(t);
-        SkASSERT(index <= 0xFFFF);
-        *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift];
-        fx += dx;
-        fy += dy;
-        b += db;
-    }
-}
-}
-
-/////////////////////////////////////////////////////////////////////
-
-static SkMatrix pts_to_unit(const SkPoint& start, SkScalar diffRadius) {
-    SkScalar inv = diffRadius ? SkScalarInvert(diffRadius) : 0;
-    SkMatrix matrix;
-    matrix.setTranslate(-start.fX, -start.fY);
-    matrix.postScale(inv, inv);
-    return matrix;
-}
-
-SkTwoPointRadialGradient::SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius,
-                                                   const SkPoint& end, SkScalar endRadius,
-                                                   const Descriptor& desc)
-    : SkGradientShaderBase(desc, pts_to_unit(start, endRadius - startRadius))
-    , fCenter1(start)
-    , fCenter2(end)
-    , fRadius1(startRadius)
-    , fRadius2(endRadius)
-{
-    fDiff = fCenter1 - fCenter2;
-    fDiffRadius = fRadius2 - fRadius1;
-    // hack to avoid zero-divide for now
-    SkScalar inv = fDiffRadius ? SkScalarInvert(fDiffRadius) : 0;
-    fDiff.fX = SkScalarMul(fDiff.fX, inv);
-    fDiff.fY = SkScalarMul(fDiff.fY, inv);
-    fStartRadius = SkScalarMul(fRadius1, inv);
-    fSr2D2 = SkScalarSquare(fStartRadius);
-    fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
-    fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
-}
-
-SkShader::BitmapType SkTwoPointRadialGradient::asABitmap(
-    SkBitmap* bitmap,
-    SkMatrix* matrix,
-    SkShader::TileMode* xy) const {
-    if (bitmap) {
-        this->getGradientTableBitmap(bitmap);
-    }
-    SkScalar diffL = 0; // just to avoid gcc warning
-    if (matrix) {
-        diffL = SkScalarSqrt(SkScalarSquare(fDiff.fX) +
-                             SkScalarSquare(fDiff.fY));
-    }
-    if (matrix) {
-        if (diffL) {
-            SkScalar invDiffL = SkScalarInvert(diffL);
-            matrix->setSinCos(-SkScalarMul(invDiffL, fDiff.fY),
-                              SkScalarMul(invDiffL, fDiff.fX));
-        } else {
-            matrix->reset();
-        }
-        matrix->preConcat(fPtsToUnit);
-    }
-    if (xy) {
-        xy[0] = fTileMode;
-        xy[1] = kClamp_TileMode;
-    }
-    return kTwoPointRadial_BitmapType;
-}
-
-SkShader::GradientType SkTwoPointRadialGradient::asAGradient(
-    SkShader::GradientInfo* info) const {
-    if (info) {
-        commonAsAGradient(info);
-        info->fPoint[0] = fCenter1;
-        info->fPoint[1] = fCenter2;
-        info->fRadius[0] = fRadius1;
-        info->fRadius[1] = fRadius2;
-    }
-    return kRadial2_GradientType;
-}
-
-size_t SkTwoPointRadialGradient::contextSize() const {
-    return sizeof(TwoPointRadialGradientContext);
-}
-
-SkShader::Context* SkTwoPointRadialGradient::onCreateContext(const ContextRec& rec,
-                                                             void* storage) const {
-    // For now, we might have divided by zero, so detect that.
-    if (0 == fDiffRadius) {
-        return NULL;
-    }
-    return SkNEW_PLACEMENT_ARGS(storage, TwoPointRadialGradientContext, (*this, rec));
-}
-
-SkTwoPointRadialGradient::TwoPointRadialGradientContext::TwoPointRadialGradientContext(
-        const SkTwoPointRadialGradient& shader, const ContextRec& rec)
-    : INHERITED(shader, rec)
-{
-    // we don't have a span16 proc
-    fFlags &= ~kHasSpan16_Flag;
-}
-
-void SkTwoPointRadialGradient::TwoPointRadialGradientContext::shadeSpan(
-        int x, int y, SkPMColor* dstCParam, int count) {
-    SkASSERT(count > 0);
-
-    const SkTwoPointRadialGradient& twoPointRadialGradient =
-            static_cast<const SkTwoPointRadialGradient&>(fShader);
-
-    SkPMColor* SK_RESTRICT dstC = dstCParam;
-
-    // Zero difference between radii:  fill with transparent black.
-    if (twoPointRadialGradient.fDiffRadius == 0) {
-      sk_bzero(dstC, count * sizeof(*dstC));
-      return;
-    }
-    SkMatrix::MapXYProc dstProc = fDstToIndexProc;
-    TileProc            proc = twoPointRadialGradient.fTileProc;
-    const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
-
-    SkScalar foura = twoPointRadialGradient.fA * 4;
-    bool posRoot = twoPointRadialGradient.fDiffRadius < 0;
-    if (fDstToIndexClass != kPerspective_MatrixClass) {
-        SkPoint srcPt;
-        dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
-                             SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-        SkScalar dx, fx = srcPt.fX;
-        SkScalar dy, fy = srcPt.fY;
-
-        if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
-            SkFixed fixedX, fixedY;
-            (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
-            dx = SkFixedToScalar(fixedX);
-            dy = SkFixedToScalar(fixedY);
-        } else {
-            SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
-            dx = fDstToIndex.getScaleX();
-            dy = fDstToIndex.getSkewY();
-        }
-        SkScalar b = (SkScalarMul(twoPointRadialGradient.fDiff.fX, fx) +
-                     SkScalarMul(twoPointRadialGradient.fDiff.fY, fy) -
-                     twoPointRadialGradient.fStartRadius) * 2;
-        SkScalar db = (SkScalarMul(twoPointRadialGradient.fDiff.fX, dx) +
-                      SkScalarMul(twoPointRadialGradient.fDiff.fY, dy)) * 2;
-
-        TwoPointRadialShadeProc shadeProc = shadeSpan_twopoint_repeat;
-        if (SkShader::kClamp_TileMode == twoPointRadialGradient.fTileMode) {
-            shadeProc = shadeSpan_twopoint_clamp;
-        } else if (SkShader::kMirror_TileMode == twoPointRadialGradient.fTileMode) {
-            shadeProc = shadeSpan_twopoint_mirror;
-        } else {
-            SkASSERT(SkShader::kRepeat_TileMode == twoPointRadialGradient.fTileMode);
-        }
-        (*shadeProc)(fx, dx, fy, dy, b, db,
-                     twoPointRadialGradient.fSr2D2, foura,
-                     twoPointRadialGradient.fOneOverTwoA, posRoot,
-                     dstC, cache, count);
-    } else {    // perspective case
-        SkScalar dstX = SkIntToScalar(x);
-        SkScalar dstY = SkIntToScalar(y);
-        for (; count > 0; --count) {
-            SkPoint             srcPt;
-            dstProc(fDstToIndex, dstX, dstY, &srcPt);
-            SkScalar fx = srcPt.fX;
-            SkScalar fy = srcPt.fY;
-            SkScalar b = (SkScalarMul(twoPointRadialGradient.fDiff.fX, fx) +
-                         SkScalarMul(twoPointRadialGradient.fDiff.fY, fy) -
-                         twoPointRadialGradient.fStartRadius) * 2;
-            SkFixed t = two_point_radial(b, fx, fy, twoPointRadialGradient.fSr2D2, foura,
-                                         twoPointRadialGradient.fOneOverTwoA, posRoot);
-            SkFixed index = proc(t);
-            SkASSERT(index <= 0xFFFF);
-            *dstC++ = cache[index >> SkGradientShaderBase::kCache32Shift];
-            dstX += SK_Scalar1;
-        }
-    }
-}
-
-#ifndef SK_IGNORE_TO_STRING
-void SkTwoPointRadialGradient::toString(SkString* str) const {
-    str->append("SkTwoPointRadialGradient: (");
-
-    str->append("center1: (");
-    str->appendScalar(fCenter1.fX);
-    str->append(", ");
-    str->appendScalar(fCenter1.fY);
-    str->append(") radius1: ");
-    str->appendScalar(fRadius1);
-    str->append(" ");
-
-    str->append("center2: (");
-    str->appendScalar(fCenter2.fX);
-    str->append(", ");
-    str->appendScalar(fCenter2.fY);
-    str->append(") radius2: ");
-    str->appendScalar(fRadius2);
-    str->append(" ");
-
-    this->INHERITED::toString(str);
-
-    str->append(")");
-}
-#endif
-
-SkFlattenable* SkTwoPointRadialGradient::CreateProc(SkReadBuffer& buffer) {
-    DescriptorScope desc;
-    if (!desc.unflatten(buffer)) {
-        return NULL;
-    }
-    const SkPoint c1 = buffer.readPoint();
-    const SkPoint c2 = buffer.readPoint();
-    const SkScalar r1 = buffer.readScalar();
-    const SkScalar r2 = buffer.readScalar();
-    return SkGradientShader::CreateTwoPointRadial(c1, r1, c2, r2, desc.fColors, desc.fPos,
-                                                  desc.fCount, desc.fTileMode, desc.fGradFlags,
-                                                  desc.fLocalMatrix);
-}
-
-void SkTwoPointRadialGradient::flatten(
-    SkWriteBuffer& buffer) const {
-    this->INHERITED::flatten(buffer);
-    buffer.writePoint(fCenter1);
-    buffer.writePoint(fCenter2);
-    buffer.writeScalar(fRadius1);
-    buffer.writeScalar(fRadius2);
-}
-
-/////////////////////////////////////////////////////////////////////
-
-#if SK_SUPPORT_GPU
-
-#include "SkGr.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-
-// For brevity
-typedef GrGLProgramDataManager::UniformHandle UniformHandle;
-
-class GrGLRadial2Gradient : public GrGLGradientEffect {
-
-public:
-
-    GrGLRadial2Gradient(const GrProcessor&);
-    virtual ~GrGLRadial2Gradient() { }
-
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
-
-    static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
-
-protected:
-
-    UniformHandle fParamUni;
-
-    const char* fVSVaryingName;
-    const char* fFSVaryingName;
-
-    bool fIsDegenerate;
-
-    // @{
-    /// Values last uploaded as uniforms
-
-    SkScalar fCachedCenter;
-    SkScalar fCachedRadius;
-    bool     fCachedPosRoot;
-
-    // @}
-
-private:
-
-    typedef GrGLGradientEffect INHERITED;
-
-};
-
-/////////////////////////////////////////////////////////////////////
-
-class GrRadial2Gradient : public GrGradientEffect {
-public:
-    static GrFragmentProcessor* Create(GrContext* ctx,
-                                       const SkTwoPointRadialGradient& shader,
-                                       const SkMatrix& matrix,
-                                       SkShader::TileMode tm) {
-        return SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm));
-    }
-
-    virtual ~GrRadial2Gradient() { }
-
-    const char* name() const override { return "Two-Point Radial Gradient"; }
-
-    virtual void getGLProcessorKey(const GrGLSLCaps& caps,
-                                   GrProcessorKeyBuilder* b) const override {
-        GrGLRadial2Gradient::GenKey(*this, caps, b);
-    }
-
-    GrGLFragmentProcessor* createGLInstance() const override {
-        return SkNEW_ARGS(GrGLRadial2Gradient, (*this));
-    }
-
-    // The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
-    bool isDegenerate() const { return SK_Scalar1 == fCenterX1; }
-    SkScalar center() const { return fCenterX1; }
-    SkScalar radius() const { return fRadius0; }
-    bool isPosRoot() const { return SkToBool(fPosRoot); }
-
-private:
-    bool onIsEqual(const GrFragmentProcessor& sBase) const override {
-        const GrRadial2Gradient& s = sBase.cast<GrRadial2Gradient>();
-        return (INHERITED::onIsEqual(sBase) &&
-                this->fCenterX1 == s.fCenterX1 &&
-                this->fRadius0 == s.fRadius0 &&
-                this->fPosRoot == s.fPosRoot);
-    }
-
-    GrRadial2Gradient(GrContext* ctx,
-                      const SkTwoPointRadialGradient& shader,
-                      const SkMatrix& matrix,
-                      SkShader::TileMode tm)
-        : INHERITED(ctx, shader, matrix, tm)
-        , fCenterX1(shader.getCenterX1())
-        , fRadius0(shader.getStartRadius())
-        , fPosRoot(shader.getDiffRadius() < 0) {
-        this->initClassID<GrRadial2Gradient>();
-        // We pass the linear part of the quadratic as a varying.
-        //    float b = 2.0 * (fCenterX1 * x - fRadius0 * z)
-        fBTransform = this->getCoordTransform();
-        SkMatrix& bMatrix = *fBTransform.accessMatrix();
-        bMatrix[SkMatrix::kMScaleX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) -
-                                           SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp0]));
-        bMatrix[SkMatrix::kMSkewX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) -
-                                          SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp1]));
-        bMatrix[SkMatrix::kMTransX] = 2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMTransX]) -
-                                           SkScalarMul(fRadius0, bMatrix[SkMatrix::kMPersp2]));
-        this->addCoordTransform(&fBTransform);
-    }
-
-    GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
-
-    // @{
-    // Cache of values - these can change arbitrarily, EXCEPT
-    // we shouldn't change between degenerate and non-degenerate?!
-
-    GrCoordTransform fBTransform;
-    SkScalar         fCenterX1;
-    SkScalar         fRadius0;
-    SkBool8          fPosRoot;
-
-    // @}
-
-    typedef GrGradientEffect INHERITED;
-};
-
-/////////////////////////////////////////////////////////////////////
-
-GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadial2Gradient);
-
-GrFragmentProcessor* GrRadial2Gradient::TestCreate(SkRandom* random,
-                                                   GrContext* context,
-                                                   const GrDrawTargetCaps&,
-                                                   GrTexture**) {
-    SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
-    SkScalar radius1 = random->nextUScalar1();
-    SkPoint center2;
-    SkScalar radius2;
-    do {
-        center2.set(random->nextUScalar1(), random->nextUScalar1());
-        radius2 = random->nextUScalar1 ();
-        // There is a bug in two point radial gradients with identical radii
-    } while (radius1 == radius2);
-
-    SkColor colors[kMaxRandomGradientColors];
-    SkScalar stopsArray[kMaxRandomGradientColors];
-    SkScalar* stops = stopsArray;
-    SkShader::TileMode tm;
-    int colorCount = RandomGradientParams(random, colors, &stops, &tm);
-    SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointRadial(center1, radius1,
-                                                                         center2, radius2,
-                                                                         colors, stops, colorCount,
-                                                                         tm));
-    SkPaint paint;
-    GrFragmentProcessor* fp;
-    GrColor paintColor;
-    SkAssertResult(shader->asFragmentProcessor(context, paint,
-                                               GrTest::TestMatrix(random), NULL,
-                                               &paintColor, &fp));
-    return fp;
-}
-
-/////////////////////////////////////////////////////////////////////
-
-GrGLRadial2Gradient::GrGLRadial2Gradient(const GrProcessor& processor)
-    : fVSVaryingName(NULL)
-    , fFSVaryingName(NULL)
-    , fCachedCenter(SK_ScalarMax)
-    , fCachedRadius(-SK_ScalarMax)
-    , fCachedPosRoot(0) {
-
-    const GrRadial2Gradient& data = processor.cast<GrRadial2Gradient>();
-    fIsDegenerate = data.isDegenerate();
-}
-
-void GrGLRadial2Gradient::emitCode(GrGLFPBuilder* builder,
-                                   const GrFragmentProcessor& fp,
-                                   const char* outputColor,
-                                   const char* inputColor,
-                                   const TransformedCoordsArray& coords,
-                                   const TextureSamplerArray& samplers) {
-    const GrRadial2Gradient& ge = fp.cast<GrRadial2Gradient>();
-    this->emitUniforms(builder, ge);
-    fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                         kFloat_GrSLType, kDefault_GrSLPrecision,
-                                         "Radial2FSParams", 6);
-
-    SkString cName("c");
-    SkString ac4Name("ac4");
-    SkString rootName("root");
-    SkString t;
-    SkString p0;
-    SkString p1;
-    SkString p2;
-    SkString p3;
-    SkString p4;
-    SkString p5;
-    builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4);
-    builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5);
-
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    // We interpolate the linear component in coords[1].
-    SkASSERT(coords[0].getType() == coords[1].getType());
-    const char* coords2D;
-    SkString bVar;
-    if (kVec3f_GrSLType == coords[0].getType()) {
-        fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n",
-                               coords[0].c_str(), coords[1].c_str(), coords[0].c_str());
-        coords2D = "interpolants.xy";
-        bVar = "interpolants.z";
-    } else {
-        coords2D = coords[0].c_str();
-        bVar.printf("%s.x", coords[1].c_str());
-    }
-
-    // c = (x^2)+(y^2) - params[4]
-    fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
-                           cName.c_str(), coords2D, coords2D, p4.c_str());
-
-    // If we aren't degenerate, emit some extra code, and accept a slightly
-    // more complex coord.
-    if (!fIsDegenerate) {
-
-        // ac4 = 4.0 * params[0] * c
-        fsBuilder->codeAppendf("\tfloat %s = %s * 4.0 * %s;\n",
-                               ac4Name.c_str(), p0.c_str(),
-                               cName.c_str());
-
-        // root = sqrt(b^2-4ac)
-        // (abs to avoid exception due to fp precision)
-        fsBuilder->codeAppendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n",
-                               rootName.c_str(), bVar.c_str(), bVar.c_str(),
-                               ac4Name.c_str());
-
-        // t is: (-b + params[5] * sqrt(b^2-4ac)) * params[1]
-        t.printf("(-%s + %s * %s) * %s", bVar.c_str(), p5.c_str(),
-                 rootName.c_str(), p1.c_str());
-    } else {
-        // t is: -c/b
-        t.printf("-%s / %s", cName.c_str(), bVar.c_str());
-    }
-
-    this->emitColor(builder, ge, t.c_str(), outputColor, inputColor, samplers);
-}
-
-void GrGLRadial2Gradient::setData(const GrGLProgramDataManager& pdman,
-                                  const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
-    const GrRadial2Gradient& data = processor.cast<GrRadial2Gradient>();
-    SkASSERT(data.isDegenerate() == fIsDegenerate);
-    SkScalar centerX1 = data.center();
-    SkScalar radius0 = data.radius();
-    if (fCachedCenter != centerX1 ||
-        fCachedRadius != radius0 ||
-        fCachedPosRoot != data.isPosRoot()) {
-
-        SkScalar a = SkScalarMul(centerX1, centerX1) - SK_Scalar1;
-
-        // When we're in the degenerate (linear) case, the second
-        // value will be INF but the program doesn't read it. (We
-        // use the same 6 uniforms even though we don't need them
-        // all in the linear case just to keep the code complexity
-        // down).
-        float values[6] = {
-            SkScalarToFloat(a),
-            1 / (2.f * SkScalarToFloat(a)),
-            SkScalarToFloat(centerX1),
-            SkScalarToFloat(radius0),
-            SkScalarToFloat(SkScalarMul(radius0, radius0)),
-            data.isPosRoot() ? 1.f : -1.f
-        };
-
-        pdman.set1fv(fParamUni, 6, values);
-        fCachedCenter = centerX1;
-        fCachedRadius = radius0;
-        fCachedPosRoot = data.isPosRoot();
-    }
-}
-
-void GrGLRadial2Gradient::GenKey(const GrProcessor& processor,
-                                 const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
-    uint32_t* key = b->add32n(2);
-    key[0] = GenBaseGradientKey(processor);
-    key[1] = processor.cast<GrRadial2Gradient>().isDegenerate();
-}
-
-/////////////////////////////////////////////////////////////////////
-
-bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
-                                                   const SkMatrix&,
-                                                   const SkMatrix* localMatrix, GrColor* paintColor,
-                                                   GrFragmentProcessor** fp)  const {
-    SkASSERT(context);
-
-    // invert the localM, translate to center1 (fPtsToUni), rotate so center2 is on x axis.
-    SkMatrix matrix;
-    if (!this->getLocalMatrix().invert(&matrix)) {
-        return false;
-    }
-    if (localMatrix) {
-        SkMatrix inv;
-        if (!localMatrix->invert(&inv)) {
-            return false;
-        }
-        matrix.postConcat(inv);
-    }
-    matrix.postConcat(fPtsToUnit);
-
-    SkScalar diffLen = fDiff.length();
-    if (0 != diffLen) {
-        SkScalar invDiffLen = SkScalarInvert(diffLen);
-        SkMatrix rot;
-        rot.setSinCos(-SkScalarMul(invDiffLen, fDiff.fY),
-                       SkScalarMul(invDiffLen, fDiff.fX));
-        matrix.postConcat(rot);
-    }
-
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-    *fp = GrRadial2Gradient::Create(context, *this, matrix, fTileMode);
-
-    return true;
-}
-
-#else
-
-bool SkTwoPointRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
-                                                   const SkMatrix*,
-                                                   GrColor*, GrFragmentProcessor**)  const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
-}
-
-#endif

src/effects/gradients/SkTwoPointRadialGradient.h

@@ -1,64 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
- #ifndef SkTwoPointRadialGradient_DEFINED
- #define SkTwoPointRadialGradient_DEFINED
-
- #include "SkGradientShaderPriv.h"
-
-class SkTwoPointRadialGradient : public SkGradientShaderBase {
-public:
-    SkTwoPointRadialGradient(const SkPoint& start, SkScalar startRadius,
-                             const SkPoint& end, SkScalar endRadius,
-                             const Descriptor&);
-
-    virtual BitmapType asABitmap(SkBitmap* bitmap,
-                                 SkMatrix* matrix,
-                                 TileMode* xy) const override;
-    GradientType asAGradient(GradientInfo* info) const override;
-    virtual bool asFragmentProcessor(GrContext* context, const SkPaint&, const SkMatrix& viewM,
-                                     const SkMatrix*, GrColor*,
-                                     GrFragmentProcessor**)  const override;
-
-    size_t contextSize() const override;
-
-    class TwoPointRadialGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
-    public:
-        TwoPointRadialGradientContext(const SkTwoPointRadialGradient&, const ContextRec&);
-
-        void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
-
-    private:
-        typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
-    };
-
-    SkScalar getCenterX1() const { return fDiff.length(); }
-    SkScalar getStartRadius() const { return fStartRadius; }
-    SkScalar getDiffRadius() const { return fDiffRadius; }
-
-    SK_TO_STRING_OVERRIDE()
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTwoPointRadialGradient)
-
-protected:
-    SkTwoPointRadialGradient(SkReadBuffer& buffer);
-    void flatten(SkWriteBuffer& buffer) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
-
-private:
-    const SkPoint fCenter1;
-    const SkPoint fCenter2;
-    const SkScalar fRadius1;
-    const SkScalar fRadius2;
-    SkPoint fDiff;
-    SkScalar fStartRadius, fDiffRadius, fSr2D2, fA, fOneOverTwoA;
-
-    friend class SkGradientShader;
-    typedef SkGradientShaderBase INHERITED;
-};
-
-#endif

src/gpu/GrProcessor.cpp

@@ -49,7 +49,7 @@ GrProcessorTestFactory<GrGeometryProcessor>::GetFactories() {
  * we verify the count is as expected.  If a new factory is added, then these numbers must be
  * manually adjusted.
  */
-static const int kFPFactoryCount = 38;
+static const int kFPFactoryCount = 37;
 static const int kGPFactoryCount = 14;
 static const int kXPFactoryCount = 5;
 

src/gpu/SkGpuDevice.cpp

@@ -347,19 +347,6 @@ void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4,
-                  shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kTwoPointConical_BitmapType == 5,
-                  shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kLinear_BitmapType == 6, shader_type_mismatch);
-SK_COMPILE_ASSERT(SkShader::kLast_BitmapType == 6, shader_type_mismatch);
-
-///////////////////////////////////////////////////////////////////////////////
-
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);

src/pdf/SkPDFShader.cpp

@@ -290,58 +290,6 @@ static SkString radialCode(const SkShader::GradientInfo& info,
     return function;
 }
 
-/* The math here is all based on the description in Two_Point_Radial_Gradient,
-   with one simplification, the coordinate space has been scaled so that
-   Dr = 1.  This means we don't need to scale the entire equation by 1/Dr^2.
- */
-static SkString twoPointRadialCode(const SkShader::GradientInfo& info,
-                                   const SkMatrix& perspectiveRemover) {
-    SkScalar dx = info.fPoint[0].fX - info.fPoint[1].fX;
-    SkScalar dy = info.fPoint[0].fY - info.fPoint[1].fY;
-    SkScalar sr = info.fRadius[0];
-    SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - SK_Scalar1;
-    bool posRoot = info.fRadius[1] > info.fRadius[0];
-
-    // We start with a stack of (x y), copy it and then consume one copy in
-    // order to calculate b and the other to calculate c.
-    SkString function("{");
-
-    function.append(apply_perspective_to_coordinates(perspectiveRemover));
-
-    function.append("2 copy ");
-
-    // Calculate -b and b^2.
-    function.appendScalar(dy);
-    function.append(" mul exch ");
-    function.appendScalar(dx);
-    function.append(" mul add ");
-    function.appendScalar(sr);
-    function.append(" sub 2 mul neg dup dup mul\n");
-
-    // Calculate c
-    function.append("4 2 roll dup mul exch dup mul add ");
-    function.appendScalar(SkScalarMul(sr, sr));
-    function.append(" sub\n");
-
-    // Calculate the determinate
-    function.appendScalar(SkScalarMul(SkIntToScalar(4), a));
-    function.append(" mul sub abs sqrt\n");
-
-    // And then the final value of t.
-    if (posRoot) {
-        function.append("sub ");
-    } else {
-        function.append("add ");
-    }
-    function.appendScalar(SkScalarMul(SkIntToScalar(2), a));
-    function.append(" div\n");
-
-    tileModeCode(info.fTileMode, &function);
-    gradientFunctionCode(info, &function);
-    function.append("}");
-    return function;
-}
-
 /* Conical gradient shader, based on the Canvas spec for radial gradients
    See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient
  */
@@ -782,17 +730,6 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create(
             transformPoints[1].fX += info->fRadius[0];
             codeFunction = &radialCode;
             break;
-        case SkShader::kRadial2_GradientType: {
-            // Bail out if the radii are the same.
-            if (info->fRadius[0] == info->fRadius[1]) {
-                return NULL;
-            }
-            transformPoints[1] = transformPoints[0];
-            SkScalar dr = info->fRadius[1] - info->fRadius[0];
-            transformPoints[1].fX += dr;
-            codeFunction = &twoPointRadialCode;
-            break;
-        }
         case SkShader::kConical_GradientType: {
             transformPoints[1] = transformPoints[0];
             transformPoints[1].fX += SK_Scalar1;
@@ -852,7 +789,7 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create(
     // state.fInfo
     // in translating from x, y coordinates to the t parameter. So, we have
     // to transform the points and radii according to the calculated matrix.
-    if (state.fType == SkShader::kRadial2_GradientType) {
+    if (state.fType == SkShader::kConical_GradientType) {
         SkShader::GradientInfo twoPointRadialInfo = *info;
         SkMatrix inverseMapperMatrix;
         if (!mapperMatrix.invert(&inverseMapperMatrix)) {
@@ -1143,7 +1080,6 @@ bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
                     return false;
                 }
                 break;
-            case SkShader::kRadial2_GradientType:
             case SkShader::kConical_GradientType:
                 if (fInfo.fPoint[1] != b.fInfo.fPoint[1] ||
                         fInfo.fRadius[0] != b.fInfo.fRadius[0] ||

tests/GradientTest.cpp

@@ -107,22 +107,6 @@ static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
     REPORTER_ASSERT(reporter, info.fRadius[0] == rec.fRadius[0]);
 }
 
-static void radial2_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
-    SkAutoTUnref<SkShader> s(SkGradientShader::CreateTwoPointRadial(rec.fPoint[0],
-                                                            rec.fRadius[0],
-                                                            rec.fPoint[1],
-                                                            rec.fRadius[1],
-                                                            rec.fColors,
-                                                            rec.fPos,
-                                                            rec.fColorCount,
-                                                            rec.fTileMode));
-
-    SkShader::GradientInfo info;
-    rec.gradCheck(reporter, s, &info, SkShader::kRadial2_GradientType);
-    REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
-    REPORTER_ASSERT(reporter, !memcmp(info.fRadius, rec.fRadius, 2 * sizeof(SkScalar)));
-}
-
 static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
     SkAutoTUnref<SkShader> s(SkGradientShader::CreateSweep(rec.fPoint[0].fX,
                                                            rec.fPoint[0].fY,
@@ -203,7 +187,6 @@ static void TestGradientShaders(skiatest::Reporter* reporter) {
         color_gradproc,
         linear_gradproc,
         radial_gradproc,
-        radial2_gradproc,
         sweep_gradproc,
         conical_gradproc,
     };