Move SkShader::fLocalMatrix into SkShader constructor.

As a first step towards removing SkShader::setLocalMatrix, which will make
SkShader thread-safe, remove calls to setLocalMatrix that happen immediately
after the shader is being created. Instead, pass the matrix into the constructor
or factory method.

BUG=skia:1976
R=scroggo@google.com, reed@google.com, skyostil@google.com, mtklein@google.com

Author: dominikg@chromium.org

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

git-svn-id: http://skia.googlecode.com/svn/trunk@14401 2bbb7eff-a529-9590-31e7-b0007b416f81

19 files changed, 181 insertions, 154 deletions

diff --git a/gm/aarectmodes.cpp b/gm/aarectmodes.cpp
index a614761e69..f12ff8c63f 100644
--- a/gm/aarectmodes.cpp
+++ b/gm/aarectmodes.cpp
@@ -113,13 +113,13 @@ static SkShader* make_bg_shader() {
     *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
                                                              0xCC, 0xCC);
 
+    SkMatrix m;
+    m.setScale(SkIntToScalar(6), SkIntToScalar(6));
     SkShader* s = SkShader::CreateBitmapShader(bm,
                                                SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode);
+                                               SkShader::kRepeat_TileMode,
+                                               &m);
 
-    SkMatrix m;
-    m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-    s->setLocalMatrix(m);
     return s;
 }
 
diff --git a/gm/bigmatrix.cpp b/gm/bigmatrix.cpp
index b663b2b1ef..30de8653d9 100644
--- a/gm/bigmatrix.cpp
+++ b/gm/bigmatrix.cpp
@@ -67,14 +67,14 @@ protected:
         pixels[3] = SkPackARGB32(0xFF, 0x00, 0x00, 0xFF);
         pt.set(30 * SK_Scalar1, 30 * SK_Scalar1);
         m.mapPoints(&pt, 1);
-        SkShader* shader = SkShader::CreateBitmapShader(
-                                            bmp,
-                                            SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode);
         SkMatrix s;
         s.reset();
         s.setScale(SK_Scalar1 / 1000, SK_Scalar1 / 1000);
-        shader->setLocalMatrix(s);
+        SkShader* shader = SkShader::CreateBitmapShader(
+                                            bmp,
+                                            SkShader::kRepeat_TileMode,
+                                            SkShader::kRepeat_TileMode,
+                                            &s);
         paint.setShader(shader)->unref();
         paint.setAntiAlias(false);
         paint.setFilterLevel(SkPaint::kLow_FilterLevel);
diff --git a/gm/bitmapshader.cpp b/gm/bitmapshader.cpp
index acb2ecb22f..8085f5c42c 100644
--- a/gm/bitmapshader.cpp
+++ b/gm/bitmapshader.cpp
@@ -35,8 +35,7 @@ static void draw_mask(SkBitmap* bm) {
     canvas.drawCircle(10, 10, 10, circlePaint);
 }
 
-static void adopt_shader(SkPaint* paint, SkShader* shader, SkMatrix s) {
-    shader->setLocalMatrix(s);
+static void adopt_shader(SkPaint* paint, SkShader* shader) {
     paint->setShader(shader);
     SkSafeUnref(shader);
 }
@@ -72,7 +71,7 @@ protected:
 
             canvas->save();
             adopt_shader(&paint, SkShader::CreateBitmapShader(fBitmap, SkShader::kClamp_TileMode,
-                                                              SkShader::kClamp_TileMode), s);
+                                                              SkShader::kClamp_TileMode, &s));
 
             // draw the shader with a bitmap mask
             canvas->drawBitmap(fMask, 0, 0, &paint);
@@ -94,7 +93,7 @@ protected:
             canvas->translate(0, 25);
 
             adopt_shader(&paint, SkShader::CreateBitmapShader(fMask, SkShader::kRepeat_TileMode,
-                                                              SkShader::kRepeat_TileMode), s);
+                                                              SkShader::kRepeat_TileMode, &s));
             paint.setColor(SK_ColorRED);
 
             // draw the mask using the shader and a color
diff --git a/gm/clippedbitmapshaders.cpp b/gm/clippedbitmapshaders.cpp
index 72c0474260..ee20847726 100644
--- a/gm/clippedbitmapshaders.cpp
+++ b/gm/clippedbitmapshaders.cpp
@@ -78,15 +78,14 @@ protected:
 
     virtual void onDraw(SkCanvas* canvas) {
         SkBitmap bmp = create_bitmap();
-        SkShader* shader = SkShader::CreateBitmapShader(
-                bmp, fMode, fMode);
-
-        SkPaint paint;
         SkMatrix s;
         s.reset();
         s.setScale(8, 8);
         s.postTranslate(SLIDE_SIZE / 2, SLIDE_SIZE / 2);
-        shader->setLocalMatrix(s);
+        SkShader* shader = SkShader::CreateBitmapShader(
+                bmp, fMode, fMode, &s);
+
+        SkPaint paint;
         paint.setShader(shader)->unref();
 
         if (fHQ) {
diff --git a/gm/colortype.cpp b/gm/colortype.cpp
index a42c008912..47bc8a9ab7 100644
--- a/gm/colortype.cpp
+++ b/gm/colortype.cpp
@@ -17,11 +17,10 @@ public:
             SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE,
             SK_ColorMAGENTA, SK_ColorCYAN, SK_ColorYELLOW
         };
-        SkShader* s = SkGradientShader::CreateSweep(0,0, colors, NULL,
-                                                    SK_ARRAY_COUNT(colors));
         SkMatrix local;
         local.setRotate(180);
-        s->setLocalMatrix(local);
+        SkShader* s = SkGradientShader::CreateSweep(0,0, colors, NULL,
+                                                    SK_ARRAY_COUNT(colors), NULL, 0, &local);
 
         SkPaint paint;
         paint.setAntiAlias(true);
diff --git a/gm/convexpolyclip.cpp b/gm/convexpolyclip.cpp
index a8037aaa54..ed67434009 100644
--- a/gm/convexpolyclip.cpp
+++ b/gm/convexpolyclip.cpp
@@ -38,15 +38,15 @@ static SkBitmap make_bmp(int w, int h) {
                          SK_Scalar1};
 
     SkPaint paint;
-    paint.setShader(SkGradientShader::CreateRadial(
-                    pt, radius,
-                    colors, pos,
-                    SK_ARRAY_COUNT(colors),
-                    SkShader::kRepeat_TileMode))->unref();
     SkRect rect = SkRect::MakeWH(wScalar, hScalar);
     SkMatrix mat = SkMatrix::I();
     for (int i = 0; i < 4; ++i) {
-        paint.getShader()->setLocalMatrix(mat);
+        paint.setShader(SkGradientShader::CreateRadial(
+                        pt, radius,
+                        colors, pos,
+                        SK_ARRAY_COUNT(colors),
+                        SkShader::kRepeat_TileMode,
+                        NULL, 0, &mat))->unref();
         canvas.drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.preTranslate(6 * wScalar, 6 * hScalar);
diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp
index 92e0c384f5..3cc9026311 100644
--- a/gm/drawbitmaprect.cpp
+++ b/gm/drawbitmaprect.cpp
@@ -55,15 +55,15 @@ static void makebm(SkBitmap* bm, int w, int h) {
                          SK_Scalar1};
 
     SkPaint     paint;
-    paint.setShader(SkGradientShader::CreateRadial(
-                    pt, radius,
-                    colors, pos,
-                    SK_ARRAY_COUNT(colors),
-                    SkShader::kRepeat_TileMode))->unref();
     SkRect rect = SkRect::MakeWH(wScalar, hScalar);
     SkMatrix mat = SkMatrix::I();
     for (int i = 0; i < 4; ++i) {
-        paint.getShader()->setLocalMatrix(mat);
+        paint.setShader(SkGradientShader::CreateRadial(
+                        pt, radius,
+                        colors, pos,
+                        SK_ARRAY_COUNT(colors),
+                        SkShader::kRepeat_TileMode,
+                        NULL, 0, &mat))->unref();
         canvas.drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
diff --git a/gm/giantbitmap.cpp b/gm/giantbitmap.cpp
index c284809b16..ed4190a814 100644
--- a/gm/giantbitmap.cpp
+++ b/gm/giantbitmap.cpp
@@ -95,7 +95,6 @@ protected:
 
     virtual void onDraw(SkCanvas* canvas) {
         SkPaint paint;
-        SkShader* s = SkShader::CreateBitmapShader(getBitmap(), fMode, fMode);
 
         SkMatrix m;
         if (fDoRotate) {
@@ -106,7 +105,7 @@ protected:
             SkScalar scale = 11*SK_Scalar1/12;
             m.setScale(scale, scale);
         }
-        s->setLocalMatrix(m);
+        SkShader* s = SkShader::CreateBitmapShader(getBitmap(), fMode, fMode, &m);
 
         paint.setShader(s)->unref();
         paint.setFilterLevel(fDoFilter ? SkPaint::kLow_FilterLevel : SkPaint::kNone_FilterLevel);
diff --git a/gm/gradient_matrix.cpp b/gm/gradient_matrix.cpp
index d1d0e42d6e..b2bc5d1cd8 100644
--- a/gm/gradient_matrix.cpp
+++ b/gm/gradient_matrix.cpp
@@ -61,21 +61,22 @@ static const SkScalar TESTGRID_Y = SkIntToScalar(200);
 
 static const int IMAGES_X = 4;             // number of images per row
 
-static SkShader* make_linear_gradient(const SkPoint pts[2]) {
+static SkShader* make_linear_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
     return SkGradientShader::CreateLinear(pts, gColors, NULL, SK_ARRAY_COUNT(gColors),
-                                          SkShader::kClamp_TileMode, NULL);
+                                          SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
 }
 
-static SkShader* make_radial_gradient(const SkPoint pts[2]) {
+static SkShader* make_radial_gradient(const SkPoint pts[2], const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     float radius = (center - pts[0]).length();
     return SkGradientShader::CreateRadial(center, radius, gColors, NULL, SK_ARRAY_COUNT(gColors),
-                                          SkShader::kClamp_TileMode, NULL);
+                                          SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
 }
 
-static void draw_gradients(SkCanvas* canvas, SkShader* (*makeShader)(const SkPoint[2]),
+static void draw_gradients(SkCanvas* canvas,
+                           SkShader* (*makeShader)(const SkPoint[2], const SkMatrix&),
                            const SkPoint ptsArray[][2], int numImages) {
     // Use some nice prime numbers for the rectangle and matrix with
     // different scaling along the x and y axes (which is the bug this
@@ -97,8 +98,7 @@ static void draw_gradients(SkCanvas* canvas, SkShader* (*makeShader)(const SkPoi
         }
 
         // Setup shader and draw.
-        SkAutoTUnref<SkShader> shader(makeShader(*ptsArray));
-        shader->setLocalMatrix(shaderMat);
+        SkAutoTUnref<SkShader> shader(makeShader(*ptsArray, shaderMat));
 
         SkPaint paint;
         paint.setShader(shader);
diff --git a/gm/gradients.cpp b/gm/gradients.cpp
index d4617bc813..5f84d9f3fa 100644
--- a/gm/gradients.cpp
+++ b/gm/gradients.cpp
@@ -40,31 +40,35 @@ static const GradData gGradData[] = {
 };
 
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, SkUnitMapper* mapper) {
+                            SkShader::TileMode tm, SkUnitMapper* mapper,
+                            const SkMatrix& localMatrix) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
-                                          data.fCount, tm, mapper);
+                                          data.fCount, tm, mapper, 0, &localMatrix);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, SkUnitMapper* mapper) {
+                            SkShader::TileMode tm, SkUnitMapper* mapper,
+                            const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
-                                          data.fPos, data.fCount, tm, mapper);
+                                          data.fPos, data.fCount, tm, mapper, 0, &localMatrix);
 }
 
 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
-                           SkShader::TileMode, SkUnitMapper* mapper) {
+                           SkShader::TileMode, SkUnitMapper* mapper,
+                           const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
-                                         data.fPos, data.fCount, mapper);
+                                         data.fPos, data.fCount, mapper, 0, &localMatrix);
 }
 
 static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
@@ -73,11 +77,13 @@ static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
     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, mapper);
+                                                  data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                  0, &localMatrix);
 }
 
 static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -86,11 +92,13 @@ static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                    center0, radius0,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                               SkShader::TileMode tm, SkUnitMapper* mapper);
+                               SkShader::TileMode tm, SkUnitMapper* mapper,
+                               const SkMatrix& localMatrix);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
 };
@@ -125,15 +133,15 @@ protected:
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
-                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
+                SkMatrix scale = SkMatrix::I();
 
                 if (i == 5) { // if the clamp case
-                    SkMatrix scale;
                     scale.setScale(0.5f, 0.5f);
                     scale.postTranslate(25.f, 25.f);
-                    shader->setLocalMatrix(scale);
                 }
 
+                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL, scale);
+
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
@@ -178,8 +186,6 @@ protected:
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
-                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
-
                 // apply an increasing y perspective as we move to the right
                 SkMatrix perspective;
                 perspective.setIdentity();
@@ -188,7 +194,7 @@ protected:
                 perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
                                      SkIntToScalar(10)));
 
-                shader->setLocalMatrix(perspective);
+                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL, perspective);
 
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
diff --git a/gm/gradients_2pt_conical.cpp b/gm/gradients_2pt_conical.cpp
index 93bddb2f7b..7f0467e53e 100644
--- a/gm/gradients_2pt_conical.cpp
+++ b/gm/gradients_2pt_conical.cpp
@@ -38,7 +38,8 @@ static const GradData gGradData[] = {
 };
 
 static SkShader* Make2ConicalOutside(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -47,11 +48,13 @@ static SkShader* Make2ConicalOutside(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -60,89 +63,97 @@ static SkShader* Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& d
     return SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                    center0, radius0,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalInside(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center1, (pts[1].fX - pts[0].fX) / 7,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    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, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalInsideFlip(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  center1, (pts[1].fX - pts[0].fX) / 7,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   center1, (pts[1].fX - pts[0].fX) / 7,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalInsideCenter(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center0, (pts[1].fX - pts[0].fX) / 7,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center0, (pts[1].fX - pts[0].fX) / 7,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRad(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center1, 0.f,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center1, 0.f,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRadFlip(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center1, (pts[1].fX - pts[0].fX) / 2,
-                                                  center0, 0.f,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 2,
+                                                   center0, 0.f,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRadCenter(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center0, 0.f,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center0, 0.f,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRadOutside(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -151,11 +162,13 @@ static SkShader* Make2ConicalZeroRadOutside(const SkPoint pts[2], const GradData
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRadFlipOutside(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -164,11 +177,13 @@ static SkShader* Make2ConicalZeroRadFlipOutside(const SkPoint pts[2], const Grad
     return SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                    center0, radius0,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalEdgeX(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -178,11 +193,13 @@ static SkShader* Make2ConicalEdgeX(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalEdgeY(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -192,10 +209,12 @@ static SkShader* Make2ConicalEdgeY(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 static SkShader* Make2ConicalZeroRadEdgeX(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -205,11 +224,13 @@ static SkShader* Make2ConicalZeroRadEdgeX(const SkPoint pts[2], const GradData&
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalZeroRadEdgeY(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = 0.f;
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -219,11 +240,13 @@ static SkShader* Make2ConicalZeroRadEdgeY(const SkPoint pts[2], const GradData&
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalTouchX(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -233,11 +256,13 @@ static SkShader* Make2ConicalTouchX(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalTouchY(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
@@ -247,24 +272,27 @@ static SkShader* Make2ConicalTouchY(const SkPoint pts[2], const GradData& data,
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper);
+                                                   data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 static SkShader* Make2ConicalInsideSmallRad(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             const SkMatrix& localMatrix) {
     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::CreateTwoPointConical(
-                                                  center0, 0.0000000000000000001f,
-                                                  center0, (pts[1].fX - pts[0].fX) / 2,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+    return SkGradientShader::CreateTwoPointConical(center0, 0.0000000000000000001f,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                   0, &localMatrix);
 }
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                               SkShader::TileMode tm, SkUnitMapper* mapper);
+                               SkShader::TileMode tm, SkUnitMapper* mapper,
+                               const SkMatrix& localMatrix);
 
 static const GradMaker gGradMakersOutside[] = {
     Make2ConicalOutside, Make2ConicalOutsideFlip,
@@ -336,15 +364,14 @@ protected:
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (int j = 0; j < count; j++) {
-                SkShader* shader = gradMaker[j](pts, gGradData[i], tm, NULL);
+                SkMatrix scale = SkMatrix::I();
 
                 if (i == 3) { // if the clamp case
-                    SkMatrix scale;
                     scale.setScale(0.5f, 0.5f);
                     scale.postTranslate(25.f, 25.f);
-                    shader->setLocalMatrix(scale);
                 }
 
+                SkShader* shader = gradMaker[j](pts, gGradData[i], tm, NULL, scale);
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
diff --git a/gm/hairmodes.cpp b/gm/hairmodes.cpp
index 4aa999d383..783c225e98 100644
--- a/gm/hairmodes.cpp
+++ b/gm/hairmodes.cpp
@@ -64,14 +64,12 @@ static SkShader* make_bg_shader() {
     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
     *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
 
-    SkShader* s = SkShader::CreateBitmapShader(bm,
-                                               SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode);
-
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-    s->setLocalMatrix(m);
-    return s;
+    return SkShader::CreateBitmapShader(bm,
+                                        SkShader::kRepeat_TileMode,
+                                        SkShader::kRepeat_TileMode,
+                                        &m);
 }
 
 namespace skiagm {
diff --git a/gm/mixedxfermodes.cpp b/gm/mixedxfermodes.cpp
index 4562325557..f2d7fa3b91 100644
--- a/gm/mixedxfermodes.cpp
+++ b/gm/mixedxfermodes.cpp
@@ -86,13 +86,13 @@ protected:
             SkBitmap bitmap;
             bitmap.allocN32Pixels(2, 2);
             memcpy(bitmap.getPixels(), kCheckerPixelData, sizeof(kCheckerPixelData));
+            SkMatrix lm;
+            lm.setScale(SkIntToScalar(20), SkIntToScalar(20));
             fBG.reset(SkShader::CreateBitmapShader(bitmap,
                                                    SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode));
+                                                   SkShader::kRepeat_TileMode,
+                                                   &lm));
         }
-        SkMatrix lm;
-        lm.setScale(SkIntToScalar(20), SkIntToScalar(20));
-        fBG->setLocalMatrix(lm);
 
         SkPaint bgPaint;
         bgPaint.setShader(fBG.get());
diff --git a/gm/shaderbounds.cpp b/gm/shaderbounds.cpp
index ef9a7e9015..2a52ead04b 100644
--- a/gm/shaderbounds.cpp
+++ b/gm/shaderbounds.cpp
@@ -9,7 +9,8 @@
 
 namespace skiagm {
 
-static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
+static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate,
+                            const SkMatrix& localMatrix) {
   SkPoint pts[2] = { {0, 0}, {width, height}};
   SkColor colors[2] = {SK_ColorRED, SK_ColorGREEN};
   if (alternate) {
@@ -18,7 +19,7 @@ static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
     colors[1] = SK_ColorYELLOW;
   }
   return SkGradientShader::CreateLinear(pts, colors, NULL, 2,
-                                        SkShader::kClamp_TileMode, NULL);
+                                        SkShader::kClamp_TileMode, NULL, 0, &localMatrix);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -26,7 +27,7 @@ static SkShader* MakeLinear(SkScalar width, SkScalar height, bool alternate) {
 class ShaderBoundsGM : public GM {
 public:
     typedef SkShader* (*ShaderGenFunc)(SkScalar width, SkScalar height,
-                                       bool alternate);
+                                       bool alternate, const SkMatrix& localMatrix);
     ShaderBoundsGM(ShaderGenFunc maker, const SkString& name)
         : fShaderMaker(maker),
           fName(name) {
@@ -80,10 +81,9 @@ protected:
         }
         SkScalar shaderWidth = SkScalarDiv(SkIntToScalar(width), scale);
         SkScalar shaderHeight = SkScalarDiv(SkIntToScalar(height), scale);
-        SkShader* shader = fShaderMaker(shaderWidth, shaderHeight, background);
         SkMatrix shaderScale;
         shaderScale.setScale(scale, scale);
-        shader->setLocalMatrix(shaderScale);
+        SkShader* shader = fShaderMaker(shaderWidth, shaderHeight, background, shaderScale);
         return shader;
     }
 
diff --git a/gm/shadertext2.cpp b/gm/shadertext2.cpp
index f839161dae..e580d91e1e 100644
--- a/gm/shadertext2.cpp
+++ b/gm/shadertext2.cpp
@@ -95,14 +95,10 @@ protected:
             makebm(&bmp, kPointSize / 2, kPointSize / 2);
         }
 
-        SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(bmp,
-                                                                   SkShader::kMirror_TileMode,
-                                                                   SkShader::kRepeat_TileMode));
         SkPaint fillPaint;
         fillPaint.setAntiAlias(true);
         fillPaint.setTextSize(SkIntToScalar(kPointSize));
         fillPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
-        fillPaint.setShader(shader);
 
         SkPaint outlinePaint;
         outlinePaint.setAntiAlias(true);
@@ -158,7 +154,10 @@ protected:
                 canvas->translate(0, kPadY / 2 + kPointSize);
                 columnH += kPadY / 2 + kPointSize;
                 for (int lm = 0; lm < localMatrices.count(); ++lm) {
-                    shader->setLocalMatrix(localMatrices[lm].fMatrix);
+                    paint.setShader(SkShader::CreateBitmapShader(bmp,
+                                                                 SkShader::kMirror_TileMode,
+                                                                 SkShader::kRepeat_TileMode,
+                                                                 &localMatrices[lm].fMatrix));
 
                     canvas->save();
                         canvas->concat(matrices[m].fMatrix);
diff --git a/gm/shadertext3.cpp b/gm/shadertext3.cpp
index a1c2d6006b..6ae3159b91 100644
--- a/gm/shadertext3.cpp
+++ b/gm/shadertext3.cpp
@@ -100,14 +100,15 @@ protected:
         int i = 0;
         for (size_t tm0 = 0; tm0 < SK_ARRAY_COUNT(kTileModes); ++tm0) {
             for (size_t tm1 = 0; tm1 < SK_ARRAY_COUNT(kTileModes); ++tm1) {
-                SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(fBmp,
-                                                                           kTileModes[tm0],
-                                                                           kTileModes[tm1]));
                 SkMatrix localM;
                 localM.setTranslate(5.f, 5.f);
                 localM.postRotate(20);
                 localM.postScale(1.15f, .85f);
-                shader->setLocalMatrix(localM);
+
+                SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(fBmp,
+                                                                           kTileModes[tm0],
+                                                                           kTileModes[tm1],
+                                                                           &localM));
 
                 SkPaint fillPaint;
                 fillPaint.setAntiAlias(true);
diff --git a/gm/xfermodes.cpp b/gm/xfermodes.cpp
index 24c48ee747..16d6cbb34b 100644
--- a/gm/xfermodes.cpp
+++ b/gm/xfermodes.cpp
@@ -216,12 +216,12 @@ protected:
 
         const SkScalar w = SkIntToScalar(W);
         const SkScalar h = SkIntToScalar(H);
-        SkShader* s = SkShader::CreateBitmapShader(fBG,
-                                                   SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode);
         SkMatrix m;
         m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-        s->setLocalMatrix(m);
+        SkShader* s = SkShader::CreateBitmapShader(fBG,
+                                                   SkShader::kRepeat_TileMode,
+                                                   SkShader::kRepeat_TileMode,
+                                                   &m);
 
         SkPaint labelP;
         labelP.setAntiAlias(true);
diff --git a/gm/xfermodes2.cpp b/gm/xfermodes2.cpp
index 1af59d2553..2ccabc61cb 100644
--- a/gm/xfermodes2.cpp
+++ b/gm/xfermodes2.cpp
@@ -96,12 +96,12 @@ private:
         bg.allocN32Pixels(2, 2, true);
         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
 
-        fBG.reset(SkShader::CreateBitmapShader(bg,
-                                               SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode));
         SkMatrix lm;
         lm.setScale(SkIntToScalar(16), SkIntToScalar(16));
-        fBG->setLocalMatrix(lm);
+        fBG.reset(SkShader::CreateBitmapShader(bg,
+                                               SkShader::kRepeat_TileMode,
+                                               SkShader::kRepeat_TileMode,
+                                               &lm));
 
         SkBitmap dstBmp;
         dstBmp.allocN32Pixels(kSize, kSize);
diff --git a/gm/xfermodes3.cpp b/gm/xfermodes3.cpp
index 1863a3e610..d5790d5e8a 100644
--- a/gm/xfermodes3.cpp
+++ b/gm/xfermodes3.cpp
@@ -195,12 +195,12 @@ private:
         SkAutoLockPixels bgAlp(bg);
         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
 
-        fBGShader.reset(SkShader::CreateBitmapShader(bg,
-                                                     SkShader::kRepeat_TileMode,
-                                                     SkShader::kRepeat_TileMode));
         SkMatrix lm;
         lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
-        fBGShader->setLocalMatrix(lm);
+        fBGShader.reset(SkShader::CreateBitmapShader(bg,
+                                                     SkShader::kRepeat_TileMode,
+                                                     SkShader::kRepeat_TileMode,
+                                                     &lm));
 
         SkPaint bmpPaint;
         static const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };