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

gm/multipicturedraw.cpp

 /*
  * Copyright 2014 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 "SkColorFilter.h"
 #include "SkMultiPictureDraw.h"
 #include "SkPictureRecorder.h"
 #include "SkSurface.h"
 
-static const SkScalar kRoot3Over2 = 0.86602545f;  // sin(60)
-static const SkScalar kRoot3      = 1.73205081f;
+constexpr SkScalar kRoot3Over2 = 0.86602545f;  // sin(60)
+constexpr SkScalar kRoot3      = 1.73205081f;
 
-static const int kHexSide = 30;
-static const int kNumHexX = 6;
-static const int kNumHexY = 6;
-static const int kPicWidth = kNumHexX * kHexSide;
-static const int kPicHeight = SkScalarCeilToInt((kNumHexY - 0.5f) * 2 * kHexSide * kRoot3Over2);
-static const SkScalar kInset = 20.0f;
-static const int kNumPictures = 4;
+constexpr int kHexSide = 30;
+constexpr int kNumHexX = 6;
+constexpr int kNumHexY = 6;
+constexpr int kPicWidth = kNumHexX * kHexSide;
+constexpr int kPicHeight = (int)((kNumHexY - 0.5f) * 2 * kHexSide * kRoot3Over2 + 0.5f);
+constexpr SkScalar kInset = 20.0f;
+constexpr int kNumPictures = 4;
 
-static const int kTriSide = 40;
+constexpr int kTriSide = 40;
 
 // Create a hexagon centered at (originX, originY)
 static SkPath make_hex_path(SkScalar originX, SkScalar originY) {
     SkPath hex;
     hex.moveTo(originX-kHexSide, originY);
     hex.rLineTo(SkScalarHalf(kHexSide), kRoot3Over2 * kHexSide);
     hex.rLineTo(SkIntToScalar(kHexSide), 0);
     hex.rLineTo(SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
     hex.rLineTo(-SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
     hex.rLineTo(-SkIntToScalar(kHexSide), 0);
@@ skipping 62 matching lines @@
     greyFill.setStyle(SkPaint::kFill_Style);
     greyFill.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
 
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(3);
 
     SkPictureRecorder recorder;
     SkRTreeFactory bbhFactory;
 
-    static const SkScalar kBig = 10000.0f;
+    constexpr SkScalar kBig = 10000.0f;
     SkCanvas* canvas = recorder.beginRecording(kBig, kBig, &bbhFactory);
 
     canvas->saveLayer(nullptr, nullptr);
 
     SkScalar xPos = 0.0f, yPos = 0.0f;
 
     for (int y = 0; yPos < kBig; ++y) {
         xPos = 0;
 
         for (int x = 0; xPos < kBig; ++x) {
@@ skipping 91 matching lines @@
 static sk_sp<SkPicture> make_sierpinski_picture() {
     sk_sp<SkPicture> pic(make_tri_picture());
 
     SkPictureRecorder recorder;
     SkRTreeFactory bbhFactory;
 
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight),
                                                &bbhFactory);
 
-    static const int kNumLevels = 4;
+    constexpr int kNumLevels = 4;
     for (int i = 0; i < kNumLevels; ++i) {
         canvas->save();
             canvas->translate(kPicWidth/2 - (i+1) * (kTriSide/2.0f), 0.0f);
             for (int j = 0; j < i+1; ++j) {
                 canvas->drawPicture(pic);
                 canvas->translate(SkIntToScalar(kTriSide), 0);
             }
         canvas->restore();
 
         pic = make_sub_picture(pic.get());
@@ skipping 97 matching lines @@
         canvas->rotate(180.0f);
         canvas->translate(-SkIntToScalar(kPicWidth), -SkIntToScalar(kPicHeight));
         canvas->drawPicture(pictures[2]);
     canvas->restore();
 }
 
 static void big_layer(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
     canvas->drawPicture(pictures[3]);
 }
 
-static const PFContentMtd gContentMthds[] = {
+constexpr PFContentMtd gContentMthds[] = {
     no_clip,
     rect_clip,
     rrect_clip,
     path_clip,
     invpath_clip,
     sierpinski,
     big_layer,
 };
 
 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
@@ skipping 34 matching lines @@
     SkCanvas* subCanvas = step.fSurf->getCanvas();
 
     create_content(mpd, pfGen, pictures, subCanvas, SkMatrix::I());
 }
 
 // Draw the content into multiple canvases/tiles
 static void tiled(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
                   PFContentMtd pfGen,
                   const SkPicture* pictures[kNumPictures],
                   SkTArray<ComposeStep> *composeSteps) {
-    static const int kNumTilesX = 2;
-    static const int kNumTilesY = 2;
-    static const int kTileWidth = kPicWidth / kNumTilesX;
-    static const int kTileHeight = kPicHeight / kNumTilesY;
+    const int kNumTilesX = 2;
+    const int kNumTilesY = 2;
+    const int kTileWidth = kPicWidth / kNumTilesX;
+    const int kTileHeight = kPicHeight / kNumTilesY;
 
     SkASSERT(kPicWidth == kNumTilesX * kTileWidth);
     SkASSERT(kPicHeight == kNumTilesY * kTileHeight);
 
-    static const SkColor colors[kNumTilesX][kNumTilesY] = {
+    const SkColor colors[kNumTilesX][kNumTilesY] = {
         { SK_ColorCYAN,   SK_ColorMAGENTA },
         { SK_ColorYELLOW, SK_ColorGREEN   }
     };
 
     for (int y = 0; y < kNumTilesY; ++y) {
         for (int x = 0; x < kNumTilesX; ++x) {
             ComposeStep& step = composeSteps->push_back();
 
             step.fX = SkIntToScalar(x*kTileWidth);
             step.fY = SkIntToScalar(y*kTileHeight);
             step.fPaint = new SkPaint;
             step.fPaint->setColorFilter(
                 SkColorFilter::MakeModeFilter(colors[x][y], SkXfermode::kModulate_Mode));
 
             step.fSurf = create_compat_surface(finalCanvas, kTileWidth, kTileHeight);
 
             SkCanvas* subCanvas = step.fSurf->getCanvas();
 
             const SkMatrix trans = SkMatrix::MakeTrans(-SkIntToScalar(x*kTileWidth),
                                                        -SkIntToScalar(y*kTileHeight));
 
             create_content(mpd, pfGen, pictures, subCanvas, trans);
         }
     }
 }
 
-static const PFLayoutMtd gLayoutMthds[] = { simple, tiled };
+constexpr PFLayoutMtd gLayoutMthds[] = { simple, tiled };
 
 namespace skiagm {
     /**
      * This GM exercises the SkMultiPictureDraw object. It tests the
      * cross product of:
      *      tiled vs. all-at-once rendering (e.g., into many or just 1 canvas)
      *      different clips (e.g., none, rect, rrect)
      *      single vs. multiple pictures (e.g., normal vs. picture-pile-style content)
      */
     class MultiPictureDraw : public GM {
     public:
         enum Content {
             kNoClipSingle_Content,
             kRectClipMulti_Content,
             kRRectClipMulti_Content,
             kPathClipMulti_Content,
             kInvPathClipMulti_Content,
             kSierpinski_Content,
             kBigLayer_Content,
 
             kLast_Content = kBigLayer_Content
         };
 
-        static const int kContentCnt = kLast_Content + 1;
+        const int kContentCnt = kLast_Content + 1;
 
         enum Layout {
             kSimple_Layout,
             kTiled_Layout,
 
             kLast_Layout = kTiled_Layout
         };
 
-        static const int kLayoutCnt = kLast_Layout + 1;
+        const int kLayoutCnt = kLast_Layout + 1;
 
         MultiPictureDraw(Content content, Layout layout) : fContent(content), fLayout(layout) {
             SkASSERT(SK_ARRAY_COUNT(gLayoutMthds) == kLayoutCnt);
             SkASSERT(SK_ARRAY_COUNT(gContentMthds) == kContentCnt);
 
             for (int i = 0; i < kNumPictures; ++i) {
                 fPictures[i] = nullptr;
             }
         }
 
@@ skipping 31 matching lines @@
                 const ComposeStep& step = composeSteps[i];
 
                 canvas->drawImage(step.fSurf->makeImageSnapshot().get(),
                                   step.fX, step.fY, step.fPaint);
             }
         }
 
         SkISize onISize() override { return SkISize::Make(kPicWidth, kPicHeight); }
 
         SkString onShortName() override {
-            static const char* gContentNames[] = {
+            const char* gContentNames[] = {
                 "noclip", "rectclip", "rrectclip", "pathclip",
                 "invpathclip", "sierpinski", "biglayer"
             };
-            static const char* gLayoutNames[] = { "simple", "tiled" };
+            const char* gLayoutNames[] = { "simple", "tiled" };
 
             SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
             SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
 
             SkString name("multipicturedraw_");
 
             name.append(gContentNames[fContent]);
             name.append("_");
             name.append(gLayoutNames[fLayout]);
             return name;
@@ skipping 28 matching lines @@
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kPathClipMulti_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kInvPathClipMulti_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kSierpinski_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kBigLayer_Content,
                                        MultiPictureDraw::kTiled_Layout);)
 }