Revert of more shader-->sp conversions (patchset #5 id:80001 of https://codereview.chromium.org/1789633002/ )

Reason for revert:
seems to have changed pictureshadertile

Original issue's description:
> more shader-->sp conversions
>
> BUG=skia:
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1789633002
>
> Committed: https://skia.googlesource.com/skia/+/ce563cdd48ec7ce4e0420dd88760df9be9dba50c

TBR=fmalita@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

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

11 files changed, 107 insertions, 59 deletions

diff --git a/tests/BitmapHeapTest.cpp b/tests/BitmapHeapTest.cpp
index 89e6faf764..eb86283618 100644
--- a/tests/BitmapHeapTest.cpp
+++ b/tests/BitmapHeapTest.cpp
@@ -50,8 +50,9 @@ DEF_TEST(BitmapHeap, reporter) {
     uint32_t* pixel = bm.getAddr32(1,0);
     *pixel = SK_ColorBLUE;
 
-    auto bitmapShader = SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode);
+    SkShader* bitmapShader = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+                                                          SkShader::kRepeat_TileMode);
+    SkAutoTUnref<SkShader> aur(bitmapShader);
 
     // Flatten, storing it in the bitmap heap.
     SkBitmapHeap heap(1, 1);
diff --git a/tests/BlitRowTest.cpp b/tests/BlitRowTest.cpp
index 032acdac39..b6a24eb98d 100644
--- a/tests/BlitRowTest.cpp
+++ b/tests/BlitRowTest.cpp
@@ -166,8 +166,10 @@ struct Mesh {
         fPts[1].set(w, 0);
         fPts[2].set(w, h);
         fPts[3].set(0, h);
-        paint->setShader(SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
-                                                    SkShader::kClamp_TileMode));
+        SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
+                                                   SkShader::kClamp_TileMode);
+        paint->setShader(s)->unref();
+
     }
 
     void draw(SkCanvas* canvas, SkPaint* paint) {
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 8681ca4f18..f34430f475 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -415,8 +415,9 @@ static void DrawVerticesShaderTestStep(SkCanvas* canvas, const TestData& d,
     pts[2].set(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight));
     pts[3].set(0, SkIntToScalar(d.fHeight));
     SkPaint paint;
-    paint.setShader(SkShader::MakeBitmapShader(d.fBitmap, SkShader::kClamp_TileMode,
-                                               SkShader::kClamp_TileMode));
+    SkShader* shader = SkShader::CreateBitmapShader(d.fBitmap,
+        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    paint.setShader(shader)->unref();
     canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
                          nullptr, nullptr, nullptr, 0, paint);
 }
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index 8928d4c909..88b9437935 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -195,9 +195,11 @@ static void test_wacky_bitmapshader(skiatest::Reporter* reporter,
                   0.0078740157f,
                   SkIntToScalar(239),
                   0, 0, SK_Scalar1);
+    SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
+                                               SkShader::kRepeat_TileMode, &matrix);
+
     SkPaint paint;
-    paint.setShader(SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode, &matrix));
+    paint.setShader(s)->unref();
 
     SkRect r = SkRect::MakeXYWH(681, 239, 695, 253);
     c.drawRect(r, paint);
diff --git a/tests/GradientTest.cpp b/tests/GradientTest.cpp
index 6521070552..cc94cbaf75 100644
--- a/tests/GradientTest.cpp
+++ b/tests/GradientTest.cpp
@@ -20,9 +20,9 @@
 static void test_big_grad(skiatest::Reporter* reporter) {
     const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
     const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
+    SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(s)->unref();
 
     SkBitmap bm;
     bm.allocN32Pixels(2000, 1);
@@ -46,7 +46,7 @@ struct GradRec {
     const SkScalar* fRadius; // 2
     SkShader::TileMode fTileMode;
 
-    void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
+    void gradCheck(skiatest::Reporter* reporter, SkShader* shader,
                    SkShader::GradientInfo* info,
                    SkShader::GradientType gt) const {
         SkAutoTMalloc<SkColor> colorStorage(fColorCount);
@@ -68,7 +68,7 @@ struct GradRec {
 
 
 static void none_gradproc(skiatest::Reporter* reporter, const GradRec&) {
-    sk_sp<SkShader> s(SkShader::MakeEmptyShader());
+    SkAutoTUnref<SkShader> s(SkShader::CreateEmptyShader());
     REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
 }
 
@@ -84,8 +84,11 @@ static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
 }
 
 static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
-    sk_sp<SkShader> s(SkGradientShader::MakeLinear(rec.fPoint, rec.fColors, rec.fPos,
-                                                   rec.fColorCount, rec.fTileMode));
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateLinear(rec.fPoint,
+                                                            rec.fColors,
+                                                            rec.fPos,
+                                                            rec.fColorCount,
+                                                            rec.fTileMode));
 
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
@@ -93,8 +96,12 @@ static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
 }
 
 static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
-    sk_sp<SkShader> s(SkGradientShader::MakeRadial(rec.fPoint[0], rec.fRadius[0], rec.fColors,
-                                                   rec.fPos, rec.fColorCount, rec.fTileMode));
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateRadial(rec.fPoint[0],
+                                                            rec.fRadius[0],
+                                                            rec.fColors,
+                                                            rec.fPos,
+                                                            rec.fColorCount,
+                                                            rec.fTileMode));
 
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
@@ -103,8 +110,11 @@ static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
 }
 
 static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
-    sk_sp<SkShader> s(SkGradientShader::MakeSweep(rec.fPoint[0].fX, rec.fPoint[0].fY, rec.fColors,
-                                                  rec.fPos, rec.fColorCount));
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateSweep(rec.fPoint[0].fX,
+                                                           rec.fPoint[0].fY,
+                                                           rec.fColors,
+                                                           rec.fPos,
+                                                           rec.fColorCount));
 
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
@@ -112,14 +122,14 @@ static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
 }
 
 static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& rec) {
-    sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(rec.fPoint[0],
-                                                            rec.fRadius[0],
-                                                            rec.fPoint[1],
-                                                            rec.fRadius[1],
-                                                            rec.fColors,
-                                                            rec.fPos,
-                                                            rec.fColorCount,
-                                                            rec.fTileMode));
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateTwoPointConical(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::kConical_GradientType);
@@ -135,10 +145,15 @@ static void TestConstantGradient(skiatest::Reporter*) {
     };
     SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
     const SkScalar pos[] = { 0, SK_Scalar1 };
-    SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateLinear(pts,
+                                                            colors,
+                                                            pos,
+                                                            2,
+                                                            SkShader::kClamp_TileMode));
     SkBitmap outBitmap;
     outBitmap.allocN32Pixels(10, 1);
+    SkPaint paint;
+    paint.setShader(s.get());
     SkCanvas canvas(outBitmap);
     canvas.drawPaint(paint);
     SkAutoLockPixels alp(outBitmap);
@@ -189,8 +204,11 @@ static void test_nearly_vertical(skiatest::Reporter* reporter) {
     const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
     const SkScalar pos[] = { 0, 1 };
+    SkAutoTUnref<SkShader> gradient(
+        SkGradientShader::CreateLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
+    paint.setShader(gradient);
 
     surface->getCanvas()->drawPaint(paint);
 }
@@ -206,9 +224,12 @@ static void test_linear_fuzz(skiatest::Reporter* reporter) {
     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
     const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
 
-    SkPaint paint;
-    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
 
+    SkAutoTUnref<SkShader> gradient(
+                   SkGradientShader::CreateLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
+
+    SkPaint paint;
+    paint.setShader(gradient);
     SkRect r = {0, 83, 1254, 620};
     surface->getCanvas()->drawRect(r, paint);
 }
@@ -220,11 +241,12 @@ static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
     surface->getCanvas()->clear(SK_ColorRED);
 
     const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
-    SkPaint p;
-    p.setShader(SkGradientShader::MakeTwoPointConical(
+    SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(
         SkPoint::Make(2.5f, 2.5f), 0,
         SkPoint::Make(3.0f, 3.0f), 10,
         colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+    SkPaint p;
+    p.setShader(shader);
     surface->getCanvas()->drawPaint(p);
 
     // r == 0 for the center pixel.
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index dfb0d35e48..3def8f5cca 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -374,9 +374,12 @@ static SkBitmap make_gradient_circle(int width, int height) {
     SkColor colors[2];
     colors[0] = SK_ColorWHITE;
     colors[1] = SK_ColorBLACK;
+    SkAutoTUnref<SkShader> shader(
+        SkGradientShader::CreateRadial(SkPoint::Make(x, y), radius, colors, nullptr, 2,
+                                       SkShader::kClamp_TileMode)
+    );
     SkPaint paint;
-    paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(shader);
     canvas.drawCircle(x, y, radius, paint);
     return bitmap;
 }
diff --git a/tests/PaintImageFilterTest.cpp b/tests/PaintImageFilterTest.cpp
index f1c0c2eb97..b71fe47119 100644
--- a/tests/PaintImageFilterTest.cpp
+++ b/tests/PaintImageFilterTest.cpp
@@ -30,9 +30,10 @@ static void test_unscaled(skiatest::Reporter* reporter) {
     SkScalar pos[] = {0, SK_ScalarHalf, SK_Scalar1};
     SkScalar radius = SkIntToScalar(5);
 
-    SkPaint gradientPaint;
-    gradientPaint.setShader(SkGradientShader::MakeRadial(
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateRadial(
         center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+    SkPaint gradientPaint;
+    gradientPaint.setShader(s);
 
     // Test using the image filter
     {
@@ -76,9 +77,10 @@ static void test_scaled(skiatest::Reporter* reporter) {
     SkScalar pos[] = {0, SK_ScalarHalf, SK_Scalar1};
     SkScalar radius = SkIntToScalar(5);
 
-    SkPaint gradientPaint;
-    gradientPaint.setShader(SkGradientShader::MakeRadial(
+    SkAutoTUnref<SkShader> s(SkGradientShader::CreateRadial(
         center, radius, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
+    SkPaint gradientPaint;
+    gradientPaint.setShader(s);
 
     // Test using the image filter
     {
diff --git a/tests/PictureShaderTest.cpp b/tests/PictureShaderTest.cpp
index 4da7aab511..14bdcf2d81 100644
--- a/tests/PictureShaderTest.cpp
+++ b/tests/PictureShaderTest.cpp
@@ -22,8 +22,9 @@ DEF_TEST(PictureShader_empty, reporter) {
     SkCanvas canvas(bitmap);
     canvas.clear(SK_ColorGREEN);
 
-    paint.setShader(SkShader::MakePictureShader(
-            nullptr, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr, nullptr));
+    SkShader* shader = SkShader::CreatePictureShader(
+            nullptr, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr, nullptr);
+    paint.setShader(shader)->unref();
 
     canvas.drawRect(SkRect::MakeWH(1,1), paint);
     REPORTER_ASSERT(reporter, *bitmap.getAddr32(0,0) == SK_ColorGREEN);
@@ -31,9 +32,10 @@ DEF_TEST(PictureShader_empty, reporter) {
 
     SkPictureRecorder factory;
     factory.beginRecording(0, 0, nullptr, 0);
-    sk_sp<SkPicture> picture(factory.endRecording());
-    paint.setShader(SkShader::MakePictureShader(std::move(picture), SkShader::kClamp_TileMode,
-                                                SkShader::kClamp_TileMode, nullptr, nullptr));
+    SkAutoTUnref<SkPicture> picture(factory.endRecording());
+    shader = SkShader::CreatePictureShader(
+            picture.get(), SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr, nullptr);
+    paint.setShader(shader)->unref();
 
     canvas.drawRect(SkRect::MakeWH(1,1), paint);
     REPORTER_ASSERT(reporter, *bitmap.getAddr32(0,0) == SK_ColorGREEN);
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 3654a77173..448e079958 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -79,9 +79,10 @@ static void test_analysis(skiatest::Reporter* reporter) {
         bitmap.allocPixels(SkImageInfo::MakeN32Premul(2, 2));
         bitmap.eraseColor(SK_ColorBLUE);
         *(bitmap.getAddr32(0, 0)) = SK_ColorGREEN;
-        paint.setShader(SkShader::MakeBitmapShader(bitmap, SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode));
-        REPORTER_ASSERT(reporter, paint.getShader()->isABitmap());
+        SkShader* shader = SkShader::CreateBitmapShader(bitmap, SkShader::kClamp_TileMode,
+                                                        SkShader::kClamp_TileMode);
+        paint.setShader(shader)->unref();
+        REPORTER_ASSERT(reporter, shader->isABitmap());
 
         canvas->drawRect(SkRect::MakeWH(10, 10), paint);
     }
@@ -1388,7 +1389,7 @@ DEF_TEST(Picture_getRecordingCanvas, r) {
 DEF_TEST(MiniRecorderLeftHanging, r) {
     // Any shader or other ref-counted effect will do just fine here.
     SkPaint paint;
-    paint.setShader(SkShader::MakeColorShader(SK_ColorRED));
+    paint.setShader(SkShader::CreateColorShader(SK_ColorRED))->unref();
 
     SkMiniRecorder rec;
     REPORTER_ASSERT(r, rec.drawRect(SkRect::MakeWH(20,30), paint));
diff --git a/tests/RecorderTest.cpp b/tests/RecorderTest.cpp
index 9d7fda5483..b4bc58dddd 100644
--- a/tests/RecorderTest.cpp
+++ b/tests/RecorderTest.cpp
@@ -58,7 +58,7 @@ DEF_TEST(Recorder_RefLeaking, r) {
 
     SkRect bounds = SkRect::MakeWH(320, 240);
     SkPaint paint;
-    paint.setShader(SkShader::MakeEmptyShader());
+    paint.setShader(SkShader::CreateEmptyShader())->unref();
 
     REPORTER_ASSERT(r, paint.getShader()->unique());
     {
diff --git a/tests/ShaderOpacityTest.cpp b/tests/ShaderOpacityTest.cpp
index 698d5442d8..90d25d731a 100644
--- a/tests/ShaderOpacityTest.cpp
+++ b/tests/ShaderOpacityTest.cpp
@@ -17,36 +17,42 @@ static void test_bitmap(skiatest::Reporter* reporter) {
     bmp.setInfo(info);
 
     // test 1: bitmap without pixel data
-    auto shader = SkShader::MakeBitmapShader(bmp,
+    SkShader* shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
+    shader->unref();
 
     // From this point on, we have pixels
     bmp.allocPixels(info);
 
     // test 2: not opaque by default
-    shader = SkShader::MakeBitmapShader(bmp,
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
+    shader->unref();
 
     // test 3: explicitly opaque
     bmp.setAlphaType(kOpaque_SkAlphaType);
-    shader = SkShader::MakeBitmapShader(bmp,
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, shader->isOpaque());
+    shader->unref();
 
     // test 4: explicitly not opaque
     bmp.setAlphaType(kPremul_SkAlphaType);
-    shader = SkShader::MakeBitmapShader(bmp,
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
+    shader->unref();
+
 }
 
-static void test_gradient(skiatest::Reporter* reporter) {
+static void test_gradient(skiatest::Reporter* reporter)
+{
     SkPoint pts[2];
     pts[0].iset(0, 0);
     pts[1].iset(1, 0);
@@ -58,33 +64,39 @@ static void test_gradient(skiatest::Reporter* reporter) {
     // test 1: all opaque
     colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
     colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
-    auto grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
+    SkShader* grad = SkGradientShader::CreateLinear(pts, colors, pos, count,
+                                                    mode);
     REPORTER_ASSERT(reporter, grad);
     REPORTER_ASSERT(reporter, grad->isOpaque());
+    grad->unref();
 
     // test 2: all 0 alpha
     colors[0] = SkColorSetARGB(0, 0, 0, 0);
     colors[1] = SkColorSetARGB(0, 0, 0, 0);
-    grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
+    grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
     REPORTER_ASSERT(reporter, grad);
     REPORTER_ASSERT(reporter, !grad->isOpaque());
+    grad->unref();
 
     // test 3: one opaque, one transparent
     colors[0] = SkColorSetARGB(0xFF, 0, 0, 0);
     colors[1] = SkColorSetARGB(0x40, 0, 0, 0);
-    grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
+    grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
     REPORTER_ASSERT(reporter, grad);
     REPORTER_ASSERT(reporter, !grad->isOpaque());
+    grad->unref();
 
     // test 4: test 3, swapped
     colors[0] = SkColorSetARGB(0x40, 0, 0, 0);
     colors[1] = SkColorSetARGB(0xFF, 0, 0, 0);
-    grad = SkGradientShader::MakeLinear(pts, colors, pos, count, mode);
+    grad = SkGradientShader::CreateLinear(pts, colors, pos, count, mode);
     REPORTER_ASSERT(reporter, grad);
     REPORTER_ASSERT(reporter, !grad->isOpaque());
+    grad->unref();
 }
 
-static void test_color(skiatest::Reporter* reporter) {
+static void test_color(skiatest::Reporter* reporter)
+{
     SkColorShader colorShader1(SkColorSetARGB(0,0,0,0));
     REPORTER_ASSERT(reporter, !colorShader1.isOpaque());
     SkColorShader colorShader2(SkColorSetARGB(0xFF,0,0,0));