Replace a lot of 'static const' with 'constexpr' or 'const'.

gm/bleed.cpp

 /*
  * Copyright 2013 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 "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 89 matching lines @@
         scanline[x] = outerRingColor;
     }
     result->fBitmap.setImmutable();
     result->fRect.set(2, 2, width - 2, height - 2);
     return true;
 }
 
 /** Create a black and white checked bitmap with 2 1-pixel rings around the outside edge.
     The inner ring is red and the outer ring is blue. */
 static bool make_ringed_color_bitmap(TestPixels* result, int width, int height) {
-    static const SkPMColor kBlue  = SkPreMultiplyColor(SK_ColorBLUE);
-    static const SkPMColor kRed   = SkPreMultiplyColor(SK_ColorRED);
-    static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
-    static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
+    const SkPMColor kBlue  = SkPreMultiplyColor(SK_ColorBLUE);
+    const SkPMColor kRed   = SkPreMultiplyColor(SK_ColorRED);
+    const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
+    const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
     return make_ringed_bitmap<SkPMColor>(result, width, height, kN32_SkColorType,
                                          kPremul_SkAlphaType, kBlue, kRed, kBlack, kWhite);
 }
 
 /** Makes a alpha bitmap with 1 wide rect/ring of 0s, an inset of 1s, and the interior is a 2x2
     checker board of 3/4 and 1/2. The inner checkers are large enough to fill the interior with
     the 2x2 checker grid. */
 static bool make_ringed_alpha_bitmap(TestPixels* result, int width, int height) {
-    static const uint8_t kZero = 0x00;
-    static const uint8_t kHalf = 0x80;
-    static const uint8_t k3Q   = 0xC0;
-    static const uint8_t kOne  = 0xFF;
+    constexpr uint8_t kZero = 0x00;
+    constexpr uint8_t kHalf = 0x80;
+    constexpr uint8_t k3Q   = 0xC0;
+    constexpr uint8_t kOne  = 0xFF;
     return make_ringed_bitmap<uint8_t>(result, width, height, kAlpha_8_SkColorType,
                                        kPremul_SkAlphaType, kZero, kOne, k3Q, kHalf);
 }
 
 /** Helper to reuse above functions to produce images rather than bmps */
 static void bmp_to_image(TestPixels* result) {
     SkASSERT(TestPixels::kBitmap == result->fType);
     result->fImage = SkImage::MakeFromBitmap(result->fBitmap);
     SkASSERT(result->fImage);
     result->fType = TestPixels::kImage;
@@ skipping 12 matching lines @@
 /** Alpha image case. */
 bool make_ringed_alpha_image(TestPixels* result, int width, int height) {
     if (make_ringed_alpha_bitmap(result, width, height)) {
         bmp_to_image(result);
         return true;
     }
     return false;
 }
 
 static sk_sp<SkShader> make_shader() {
-    static const SkPoint pts[] = { {0, 0}, {20, 20} };
-    static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
+    constexpr SkPoint pts[] = { {0, 0}, {20, 20} };
+    constexpr SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
     return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
 }
 
 static sk_sp<SkShader> make_null_shader() { return nullptr; }
 
 enum BleedTest {
     kUseBitmap_BleedTest,
     kUseImage_BleedTest,
     kUseAlphaBitmap_BleedTest,
     kUseAlphaImage_BleedTest,
@@ skipping 145 matching lines @@
     void onDraw(SkCanvas* canvas) override {
         fShader = gBleedRec[fBT].fShaderMaker();
 
         canvas->clear(SK_ColorGRAY);
         SkTDArray<SkMatrix> matrices;
         // Draw with identity
         *matrices.append() = SkMatrix::I();
 
         // Draw with rotation and scale down in x, up in y.
         SkMatrix m;
-        static const SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
+        constexpr SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
         m.setTranslate(0, kBottom);
         m.preRotate(15.f, 0, kBottom + kBlockSpacing);
         m.preScale(0.71f, 1.22f);
         *matrices.append() = m;
 
         // Align the next set with the middle of the previous in y, translated to the right in x.
         SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidth, 0} };
         matrices[matrices.count()-1].mapPoints(corners, 4);
         SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4;
         SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX),
@@ skipping 64 matching lines @@
         }
     }
 
 #if SK_SUPPORT_GPU
     void modifyGrContextOptions(GrContextOptions* options) override {
         options->fMaxTileSizeOverride = kMaxTileSize;
     }
 #endif
 
 private:
-    static const int kBlockSize = 70;
-    static const int kBlockSpacing = 12;
+    static constexpr int kBlockSize = 70;
+    static constexpr int kBlockSpacing = 12;
 
-    static const int kCol0X = kBlockSpacing;
-    static const int kCol1X = 2*kBlockSpacing + kBlockSize;
-    static const int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
-    static const int kCol3X = 4*kBlockSpacing + 3*kBlockSize;
-    static const int kCol4X = 5*kBlockSpacing + 4*kBlockSize;
-    static const int kCol5X = 6*kBlockSpacing + 5*kBlockSize;
-    static const int kWidth = 7*kBlockSpacing + 6*kBlockSize;
+    static constexpr int kCol0X = kBlockSpacing;
+    static constexpr int kCol1X = 2*kBlockSpacing + kBlockSize;
+    static constexpr int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
+    static constexpr int kCol3X = 4*kBlockSpacing + 3*kBlockSize;
+    static constexpr int kCol4X = 5*kBlockSpacing + 4*kBlockSize;
+    static constexpr int kCol5X = 6*kBlockSpacing + 5*kBlockSize;
+    static constexpr int kWidth = 7*kBlockSpacing + 6*kBlockSize;
 
-    static const int kRow0Y = kBlockSpacing;
-    static const int kRow1Y = 2*kBlockSpacing + kBlockSize;
-    static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
-    static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
-    static const int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
+    static constexpr int kRow0Y = kBlockSpacing;
+    static constexpr int kRow1Y = 2*kBlockSpacing + kBlockSize;
+    static constexpr int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
+    static constexpr int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
+    static constexpr int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
 
-    static const int kSmallSize = 6;
-    static const int kMaxTileSize = 32;
+    static constexpr int kSmallSize = 6;
+    static constexpr int kMaxTileSize = 32;
 
     TestPixels      fBigTestPixels;
     TestPixels      fSmallTestPixels;
 
     sk_sp<SkShader> fShader;
 
     const BleedTest fBT;
 
     typedef GM INHERITED;
 };
@@ skipping 65 matching lines @@
             // now blow up the 1 pixel result
             canvas->drawImageRect(surf->makeImageSnapshot(), SkRect::MakeWH(100, 100), nullptr);
             canvas->translate(120, 0);
         }
         canvas->restore();
         canvas->translate(0, 120);
     }
 }