don't use local static bitmap -- racy and unnecessary

gm/shadertext.cpp

 /*
  * Copyright 2011 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 "SkGradientShader.h"
@@ skipping 10 matching lines @@
     SkColor     colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
     SkScalar    pos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
     SkPaint     paint;
 
     paint.setDither(true);
     paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
                 SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref();
     canvas.drawPaint(paint);
 }
 
-static SkShader* MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty,
-                           int w, int h) {
-    static SkBitmap bmp;
-    if (bmp.isNull()) {
-        makebm(&bmp, w/2, h/4);
-    }
-    return SkShader::CreateBitmapShader(bmp, tx, ty);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
 };
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
@@ skipping 58 matching lines @@
         return SkString("shadertext");
     }
 
     SkISize onISize() { return SkISize::Make(1450, 500); }
 
     virtual void onDraw(SkCanvas* canvas) {
         const char text[] = "Shaded Text";
         const int textLen = SK_ARRAY_COUNT(text) - 1;
         const int pointSize = 36;
 
-        int w = pointSize * textLen;
-        int h = pointSize;
+        const int w = pointSize * textLen;
+        const int h = pointSize;
 
         SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(w), SkIntToScalar(h) }
         };
         SkScalar textBase = SkIntToScalar(h/2);
 
         SkShader::TileMode tileModes[] = {
             SkShader::kClamp_TileMode,
             SkShader::kRepeat_TileMode,
             SkShader::kMirror_TileMode
         };
 
         static const int gradCount = SK_ARRAY_COUNT(gGradData) *
                                      SK_ARRAY_COUNT(gGradMakers);
         static const int bmpCount = SK_ARRAY_COUNT(tileModes) *
                                     SK_ARRAY_COUNT(tileModes);
         SkShader* shaders[gradCount + bmpCount];
 
         int shdIdx = 0;
         for (size_t d = 0; d < SK_ARRAY_COUNT(gGradData); ++d) {
             for (size_t m = 0; m < SK_ARRAY_COUNT(gGradMakers); ++m) {
                 shaders[shdIdx++] = gGradMakers[m](pts,
                                                    gGradData[d],
                                                    SkShader::kClamp_TileMode);
             }
         }
+        
+        SkBitmap bm;
+        makebm(&bm, w/16, h/4);
         for (size_t tx = 0; tx < SK_ARRAY_COUNT(tileModes); ++tx) {
             for (size_t ty = 0; ty < SK_ARRAY_COUNT(tileModes); ++ty) {
-                shaders[shdIdx++] = MakeBitmapShader(tileModes[tx],
-                                                     tileModes[ty],
-                                                     w/8, h);
+                shaders[shdIdx++] = SkShader::CreateBitmapShader(bm, tileModes[tx], tileModes[ty]);
             }
         }
 
         SkPaint paint;
         paint.setDither(true);
         paint.setAntiAlias(true);
         sk_tool_utils::set_portable_typeface(&paint);
         paint.setTextSize(SkIntToScalar(pointSize));
 
         canvas->save();
@@ skipping 31 matching lines @@
 
 private:
     typedef GM INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static GM* MyFactory(void*) { return new ShaderTextGM; }
 static GMRegistry reg(MyFactory);
 }