Use static_assert instead of SK_COMPILE_ASSERT.

src/gpu/GrPath.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPath.h"
 
 namespace {
 // Verb count limit for generating path key from content of a volatile path.
 // The value should accomodate at least simple rects and rrects.
 static const int kSimpleVolatilePathVerbLimit = 10;
 
 inline static bool compute_key_for_line_path(const SkPath& path, const GrStrokeInfo& stroke,
                                              GrUniqueKey* key) {
     SkPoint pts[2];
     if (!path.isLine(pts)) {
         return false;
     }
-    SK_COMPILE_ASSERT((sizeof(pts) % sizeof(uint32_t)) == 0 && sizeof(pts) > sizeof(uint32_t),
-                      pts_needs_padding);
+    static_assert((sizeof(pts) % sizeof(uint32_t)) == 0 && sizeof(pts) > sizeof(uint32_t),
+                  "pts_needs_padding");
 
     const int kBaseData32Cnt = 1 + sizeof(pts) / sizeof(uint32_t);
     int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
     static const GrUniqueKey::Domain kOvalPathDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + strokeDataCnt);
     builder[0] = path.getFillType();
     memcpy(&builder[1], &pts, sizeof(pts));
     if (strokeDataCnt > 0) {
         stroke.asUniqueKeyFragment(&builder[kBaseData32Cnt]);
     }
     return true;
 }
 
 inline static bool compute_key_for_oval_path(const SkPath& path, const GrStrokeInfo& stroke,
                                              GrUniqueKey* key) {
     SkRect rect;
     if (!path.isOval(&rect)) {
         return false;
     }
-    SK_COMPILE_ASSERT((sizeof(rect) % sizeof(uint32_t)) == 0 && sizeof(rect) > sizeof(uint32_t),
-                      rect_needs_padding);
+    static_assert((sizeof(rect) % sizeof(uint32_t)) == 0 && sizeof(rect) > sizeof(uint32_t),
+                  "rect_needs_padding");
 
     const int kBaseData32Cnt = 1 + sizeof(rect) / sizeof(uint32_t);
     int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
     static const GrUniqueKey::Domain kOvalPathDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + strokeDataCnt);
     builder[0] = path.getFillType();
     memcpy(&builder[1], &rect, sizeof(rect));
     if (strokeDataCnt > 0) {
         stroke.asUniqueKeyFragment(&builder[kBaseData32Cnt]);
     }
     return true;
 }
 
 // Encodes the full path data to the unique key for very small, volatile paths. This is typically
 // hit when clipping stencils the clip stack. Intention is that this handles rects too, since
 // SkPath::isRect seems to do non-trivial amount of work.
 inline static bool compute_key_for_simple_path(const SkPath& path, const GrStrokeInfo& stroke,
                                                GrUniqueKey* key) {
     if (!path.isVolatile()) {
         return false;
     }
     // The check below should take care of negative values casted positive.
     const int verbCnt = path.countVerbs();
     if (verbCnt > kSimpleVolatilePathVerbLimit) {
         return false;
     }
 
     // If somebody goes wild with the constant, it might cause an overflow.
-    SK_COMPILE_ASSERT(kSimpleVolatilePathVerbLimit <= 100,
-                      big_simple_volatile_path_verb_limit_may_cause_overflow);
+    static_assert(kSimpleVolatilePathVerbLimit <= 100,
+                  "big_simple_volatile_path_verb_limit_may_cause_overflow");
 
     const int pointCnt = path.countPoints();
     if (pointCnt < 0) {
         SkASSERT(false);
         return false;
     }
 
     // Construct counts that align as uint32_t counts.
 #define ARRAY_DATA32_COUNT(array_type, count) \
     static_cast<int>((((count) * sizeof(array_type) + sizeof(uint32_t) - 1) / sizeof(uint32_t)))
@@ skipping 30 matching lines @@
 
     // Fill the last uint32_t with 0 first, since the last uint8_ts of the uint32_t may be
     // uninitialized. This does not produce ambiguous verb data, since we have serialized the exact
     // verb count.
     if (verbData32Cnt != static_cast<int>((verbCnt * sizeof(uint8_t) / sizeof(uint32_t)))) {
         builder[i + verbData32Cnt - 1] = 0;
     }
     path.getVerbs(reinterpret_cast<uint8_t*>(&builder[i]), verbCnt);
     i += verbData32Cnt;
 
-    SK_COMPILE_ASSERT(((sizeof(SkPoint) % sizeof(uint32_t)) == 0) &&
-                      sizeof(SkPoint) > sizeof(uint32_t), skpoint_array_needs_padding);
+    static_assert(((sizeof(SkPoint) % sizeof(uint32_t)) == 0) && sizeof(SkPoint) > sizeof(uint32_t),
+                  "skpoint_array_needs_padding");
 
     // Here we assume getPoints does a memcpy, so that we do not need to worry about the alignment.
     path.getPoints(reinterpret_cast<SkPoint*>(&builder[i]), pointCnt);
     SkDEBUGCODE(i += pointData32Cnt);
 
     SkASSERT(i == baseData32Cnt);
     if (strokeDataCnt > 0) {
         stroke.asUniqueKeyFragment(&builder[baseData32Cnt]);
     }
     return true;
@@ skipping 28 matching lines @@
 
     if (compute_key_for_simple_path(path, stroke, key)) {
         *outIsVolatile = false;
         return;
     }
 
     compute_key_for_general_path(path, stroke, key);
     *outIsVolatile = path.isVolatile();
 }