diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index fe6694d..02afe92 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -48,15 +48,15 @@
  */
 bool SkCanvas::wouldOverwriteEntireSurface(const SkRect* rect, const SkPaint* paint,
                                            ShaderOverrideOpacity overrideOpacity) const {
-    SK_COMPILE_ASSERT((int)SkPaintPriv::kNone_ShaderOverrideOpacity ==
-                      (int)kNone_ShaderOverrideOpacity,
-                      need_matching_enums0);
-    SK_COMPILE_ASSERT((int)SkPaintPriv::kOpaque_ShaderOverrideOpacity ==
-                      (int)kOpaque_ShaderOverrideOpacity,
-                      need_matching_enums1);
-    SK_COMPILE_ASSERT((int)SkPaintPriv::kNotOpaque_ShaderOverrideOpacity ==
-                      (int)kNotOpaque_ShaderOverrideOpacity,
-                      need_matching_enums2);
+    static_assert((int)SkPaintPriv::kNone_ShaderOverrideOpacity ==
+                  (int)kNone_ShaderOverrideOpacity,
+                  "need_matching_enums0");
+    static_assert((int)SkPaintPriv::kOpaque_ShaderOverrideOpacity ==
+                  (int)kOpaque_ShaderOverrideOpacity,
+                  "need_matching_enums1");
+    static_assert((int)SkPaintPriv::kNotOpaque_ShaderOverrideOpacity ==
+                  (int)kNotOpaque_ShaderOverrideOpacity,
+                  "need_matching_enums2");
 
     const SkISize size = this->getBaseLayerSize();
     const SkRect bounds = SkRect::MakeIWH(size.width(), size.height());
@@ -2791,7 +2791,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCanvas::LayerIter::LayerIter(SkCanvas* canvas, bool skipEmptyClips) {
-    SK_COMPILE_ASSERT(sizeof(fStorage) >= sizeof(SkDrawIter), fStorage_too_small);
+    static_assert(sizeof(fStorage) >= sizeof(SkDrawIter), "fStorage_too_small");
 
     SkASSERT(canvas);
 
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index c4c68ce..c359e87 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -862,11 +862,11 @@
         "rrect",
         "path"
     };
-    SK_COMPILE_ASSERT(0 == kEmpty_Type, type_str);
-    SK_COMPILE_ASSERT(1 == kRect_Type, type_str);
-    SK_COMPILE_ASSERT(2 == kRRect_Type, type_str);
-    SK_COMPILE_ASSERT(3 == kPath_Type, type_str);
-    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kTypeStrings) == kTypeCnt, type_str);
+    static_assert(0 == kEmpty_Type, "type_str");
+    static_assert(1 == kRect_Type, "type_str");
+    static_assert(2 == kRRect_Type, "type_str");
+    static_assert(3 == kPath_Type, "type_str");
+    static_assert(SK_ARRAY_COUNT(kTypeStrings) == kTypeCnt, "type_str");
 
     static const char* kOpStrings[] = {
         "difference",
@@ -876,13 +876,13 @@
         "reverse-difference",
         "replace",
     };
-    SK_COMPILE_ASSERT(0 == SkRegion::kDifference_Op, op_str);
-    SK_COMPILE_ASSERT(1 == SkRegion::kIntersect_Op, op_str);
-    SK_COMPILE_ASSERT(2 == SkRegion::kUnion_Op, op_str);
-    SK_COMPILE_ASSERT(3 == SkRegion::kXOR_Op, op_str);
-    SK_COMPILE_ASSERT(4 == SkRegion::kReverseDifference_Op, op_str);
-    SK_COMPILE_ASSERT(5 == SkRegion::kReplace_Op, op_str);
-    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kOpStrings) == SkRegion::kOpCnt, op_str);
+    static_assert(0 == SkRegion::kDifference_Op, "op_str");
+    static_assert(1 == SkRegion::kIntersect_Op, "op_str");
+    static_assert(2 == SkRegion::kUnion_Op, "op_str");
+    static_assert(3 == SkRegion::kXOR_Op, "op_str");
+    static_assert(4 == SkRegion::kReverseDifference_Op, "op_str");
+    static_assert(5 == SkRegion::kReplace_Op, "op_str");
+    static_assert(SK_ARRAY_COUNT(kOpStrings) == SkRegion::kOpCnt, "op_str");
 
     SkDebugf("Type: %s, Op: %s, AA: %s, Save Count: %d\n", kTypeStrings[fType],
              kOpStrings[fOp], (fDoAA ? "yes" : "no"), fSaveCount);
diff --git a/src/core/SkConvolver.h b/src/core/SkConvolver.h
index 21419a9..4beb755 100644
--- a/src/core/SkConvolver.h
+++ b/src/core/SkConvolver.h
@@ -46,7 +46,7 @@
         // The cast relies on ConvolutionFixed being a short, implying that on
         // the platforms we care about all (16) bits will fit into
         // the mantissa of a (32-bit) float.
-        SK_COMPILE_ASSERT(sizeof(ConvolutionFixed) == 2, ConvolutionFixed_type_should_fit_in_float_mantissa);
+        static_assert(sizeof(ConvolutionFixed) == 2, "ConvolutionFixed_type_should_fit_in_float_mantissa");
         float raw = static_cast<float>(x);
         return ldexpf(raw, -kShiftBits);
     }
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index 5f9fa64..5157db2 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -106,8 +106,8 @@
     Key(const uint32_t uniqueID, const SkMatrix& matrix, const SkIRect& clipBounds, uint32_t srcGenID)
       : fUniqueID(uniqueID), fMatrix(matrix), fClipBounds(clipBounds), fSrcGenID(srcGenID) {
         // Assert that Key is tightly-packed, since it is hashed.
-        SK_COMPILE_ASSERT(sizeof(Key) == sizeof(uint32_t) + sizeof(SkMatrix) + sizeof(SkIRect) +
-                                         sizeof(uint32_t), image_filter_key_tight_packing);
+        static_assert(sizeof(Key) == sizeof(uint32_t) + sizeof(SkMatrix) + sizeof(SkIRect) +
+                                     sizeof(uint32_t), "image_filter_key_tight_packing");
         fMatrix.getType();  // force initialization of type, so hashes match
     }
     uint32_t fUniqueID;
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index 31ff4b1..e030560 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -1592,13 +1592,13 @@
 
     const SkMatrix& asSkMatrix() const { return *reinterpret_cast<const SkMatrix*>(this); }
 };
-SK_COMPILE_ASSERT(sizeof(PODMatrix) == sizeof(SkMatrix), PODMatrixSizeMismatch);
+static_assert(sizeof(PODMatrix) == sizeof(SkMatrix), "PODMatrixSizeMismatch");
 
 }  // namespace
 
 const SkMatrix& SkMatrix::I() {
-    SK_COMPILE_ASSERT(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   BadfMat);
-    SK_COMPILE_ASSERT(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), BadfTypeMask);
+    static_assert(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   "BadfMat");
+    static_assert(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), "BadfTypeMask");
 
     static const PODMatrix identity = { {SK_Scalar1, 0, 0,
                                          0, SK_Scalar1, 0,
@@ -1609,8 +1609,8 @@
 }
 
 const SkMatrix& SkMatrix::InvalidMatrix() {
-    SK_COMPILE_ASSERT(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   BadfMat);
-    SK_COMPILE_ASSERT(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), BadfTypeMask);
+    static_assert(offsetof(SkMatrix, fMat)      == offsetof(PODMatrix, matrix),   "BadfMat");
+    static_assert(offsetof(SkMatrix, fTypeMask) == offsetof(PODMatrix, typemask), "BadfTypeMask");
 
     static const PODMatrix invalid =
         { {SK_ScalarMax, SK_ScalarMax, SK_ScalarMax,
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 4ab8927..4400994 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -2429,8 +2429,8 @@
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
-    SK_COMPILE_ASSERT(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
-                      SkPaint_notPackedTightly);
+    static_assert(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
+                  "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 55262ad..2281d16 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -105,8 +105,7 @@
         1,  // DRAW_IMAGE_RECT - right after op code
     };
 
-    SK_COMPILE_ASSERT(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1,
-                      need_to_be_in_sync);
+    static_assert(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1, "need_to_be_in_sync");
     SkASSERT((unsigned)op <= (unsigned)LAST_DRAWTYPE_ENUM);
 
     int overflow = 0;
diff --git a/src/core/SkResourceCache.cpp b/src/core/SkResourceCache.cpp
index 6febbd2..70dc8f9 100644
--- a/src/core/SkResourceCache.cpp
+++ b/src/core/SkResourceCache.cpp
@@ -36,9 +36,9 @@
     static const int kHashedLocal32s = kSharedIDLocal32s + (sizeof(fNamespace) >> 2);
     static const int kLocal32s = kUnhashedLocal32s + kHashedLocal32s;
 
-    SK_COMPILE_ASSERT(sizeof(Key) == (kLocal32s << 2), unaccounted_key_locals);
-    SK_COMPILE_ASSERT(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace),
-                      namespace_field_must_be_last);
+    static_assert(sizeof(Key) == (kLocal32s << 2), "unaccounted_key_locals");
+    static_assert(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace),
+                 "namespace_field_must_be_last");
 
     fCount32 = SkToS32(kLocal32s + (length >> 2));
     fSharedID_lo = (uint32_t)sharedID;
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index d21dc96..ede3d21 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -21,10 +21,10 @@
 // largest seen for normal quads : 11
 static const int kRecursiveLimits[] = { 5*3, 26*3, 11*3, 11*3 }; // 3x limits seen in practice
 
-SK_COMPILE_ASSERT(0 == kTangent_RecursiveLimit, cubic_stroke_relies_on_tangent_equalling_zero);
-SK_COMPILE_ASSERT(1 == kCubic_RecursiveLimit, cubic_stroke_relies_on_cubic_equalling_one);
-SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kRecursiveLimits) == kQuad_RecursiveLimit + 1,
-        recursive_limits_mismatch);
+static_assert(0 == kTangent_RecursiveLimit, "cubic_stroke_relies_on_tangent_equalling_zero");
+static_assert(1 == kCubic_RecursiveLimit, "cubic_stroke_relies_on_cubic_equalling_one");
+static_assert(SK_ARRAY_COUNT(kRecursiveLimits) == kQuad_RecursiveLimit + 1,
+              "recursive_limits_mismatch");
 
 #ifdef SK_DEBUG
     int gMaxRecursion[SK_ARRAY_COUNT(kRecursiveLimits)] = { 0 };
@@ -544,9 +544,9 @@
         SkScalar t = tValues[index];
         SkEvalCubicAt(cubic, t, &reduction[index], NULL, NULL);
     }
-    SK_COMPILE_ASSERT(kQuad_ReductionType + 1 == kDegenerate_ReductionType, enum_out_of_whack);
-    SK_COMPILE_ASSERT(kQuad_ReductionType + 2 == kDegenerate2_ReductionType, enum_out_of_whack);
-    SK_COMPILE_ASSERT(kQuad_ReductionType + 3 == kDegenerate3_ReductionType, enum_out_of_whack);
+    static_assert(kQuad_ReductionType + 1 == kDegenerate_ReductionType, "enum_out_of_whack");
+    static_assert(kQuad_ReductionType + 2 == kDegenerate2_ReductionType, "enum_out_of_whack");
+    static_assert(kQuad_ReductionType + 3 == kDegenerate3_ReductionType, "enum_out_of_whack");
 
     return (ReductionType) (kQuad_ReductionType + count);
 }
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index d1a77e7..d2b1605 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -73,9 +73,9 @@
     SkAutoTUnref<SkTypeface> fTypeface;
     SkScalar                 fSkewX;
 
-    SK_COMPILE_ASSERT(SkPaint::kFull_Hinting < 4, insufficient_hinting_bits);
+    static_assert(SkPaint::kFull_Hinting < 4, "insufficient_hinting_bits");
     uint32_t                 fHinting : 2;
-    SK_COMPILE_ASSERT((kFlagsMask & 0xffff) == kFlagsMask, insufficient_flags_bits);
+    static_assert((kFlagsMask & 0xffff) == kFlagsMask, "insufficient_flags_bits");
     uint32_t                 fFlags : 16;
 
     typedef SkNoncopyable INHERITED;
@@ -87,7 +87,7 @@
     SkScalar fSkewX;
     uint32_t fFlags;
 };
-SK_COMPILE_ASSERT(sizeof(RunFont) == sizeof(RunFontStorageEquivalent), runfont_should_stay_packed);
+static_assert(sizeof(RunFont) == sizeof(RunFontStorageEquivalent), "runfont_should_stay_packed");
 
 } // anonymous namespace
 
diff --git a/src/core/SkTextFormatParams.h b/src/core/SkTextFormatParams.h
index dac4aef..f41c4de 100644
--- a/src/core/SkTextFormatParams.h
+++ b/src/core/SkTextFormatParams.h
@@ -30,12 +30,10 @@
 };
 static const SkScalar kStdFakeBoldInterpValues[] = {
     SK_Scalar1/24,
-    SK_Scalar1/32
+    SK_Scalar1/32,
 };
-SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kStdFakeBoldInterpKeys) ==
-                  SK_ARRAY_COUNT(kStdFakeBoldInterpValues),
-                  mismatched_array_size);
-static const int kStdFakeBoldInterpLength =
-    SK_ARRAY_COUNT(kStdFakeBoldInterpKeys);
+static_assert(SK_ARRAY_COUNT(kStdFakeBoldInterpKeys) == SK_ARRAY_COUNT(kStdFakeBoldInterpValues),
+              "mismatched_array_size");
+static const int kStdFakeBoldInterpLength = SK_ARRAY_COUNT(kStdFakeBoldInterpKeys);
 
 #endif  //SkTextFormatParams_DEFINES
diff --git a/src/core/SkVarAlloc.h b/src/core/SkVarAlloc.h
index e8236cf..0d09842 100644
--- a/src/core/SkVarAlloc.h
+++ b/src/core/SkVarAlloc.h
@@ -50,6 +50,6 @@
     struct Block;
     Block* fBlock;
 };
-SK_COMPILE_ASSERT(sizeof(SkVarAlloc) <= 32, SkVarAllocSize);
+static_assert(sizeof(SkVarAlloc) <= 32, "SkVarAllocSize");
 
 #endif//SkVarAlloc_DEFINED
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 59b689c..c9a8122 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -966,7 +966,7 @@
         "Multiply", "Hue", "Saturation", "Color",  "Luminosity"
     };
     return gModeStrings[mode];
-    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gModeStrings) == kLastMode + 1, mode_count);
+    static_assert(SK_ARRAY_COUNT(gModeStrings) == kLastMode + 1, "mode_count");
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index c453411..fb3ea31 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -153,7 +153,7 @@
         "kDrawShadowAndForeground", "kDrawShadowOnly"
     };
 
-    SK_COMPILE_ASSERT(kShadowModeCount == SK_ARRAY_COUNT(gModeStrings), enum_mismatch);
+    static_assert(kShadowModeCount == SK_ARRAY_COUNT(gModeStrings), "enum_mismatch");
 
     str->appendf(" mode: %s", gModeStrings[fShadowMode]);
 
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index a6a00cd..1b995cb 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -13,7 +13,7 @@
 #define kSQRT_TABLE_BITS    11
 #define kSQRT_TABLE_SIZE    (1 << kSQRT_TABLE_BITS)
 
-SK_COMPILE_ASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE, SqrtTableSizesMatch);
+static_assert(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE, "SqrtTableSizesMatch");
 
 #if 0
 
diff --git a/src/gpu/GrAtlasTextContext.cpp b/src/gpu/GrAtlasTextContext.cpp
index a556128..aa4c51d 100644
--- a/src/gpu/GrAtlasTextContext.cpp
+++ b/src/gpu/GrAtlasTextContext.cpp
@@ -103,8 +103,8 @@
     , fDistanceAdjustTable(SkNEW(DistanceAdjustTable)) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
-    SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
-                      vertex_attribute_changed);
+    static_assert(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
+                  "vertex_attribute_changed");
     fCurrStrike = NULL;
     fCache = context->getTextBlobCache();
 }
diff --git a/src/gpu/GrBatchFontCache.h b/src/gpu/GrBatchFontCache.h
index fc2f3b7..32c3281 100644
--- a/src/gpu/GrBatchFontCache.h
+++ b/src/gpu/GrBatchFontCache.h
@@ -179,7 +179,7 @@
             kRGB_565_GrPixelConfig,
             kSkia8888_GrPixelConfig
         };
-        SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kPixelConfigs) == kMaskFormatCount, array_size_mismatch);
+        static_assert(SK_ARRAY_COUNT(kPixelConfigs) == kMaskFormatCount, "array_size_mismatch");
 
         return kPixelConfigs[format];
     }
@@ -191,7 +191,7 @@
             kA565_GrMaskFormat,
             kARGB_GrMaskFormat,
         };
-        SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
+        static_assert(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, "array_size_mismatch");
 
         SkASSERT(sAtlasIndices[format] < kMaskFormatCount);
         return sAtlasIndices[format];
diff --git a/src/gpu/GrPath.cpp b/src/gpu/GrPath.cpp
index 421edd3..4e1119d 100644
--- a/src/gpu/GrPath.cpp
+++ b/src/gpu/GrPath.cpp
@@ -18,8 +18,8 @@
     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();
@@ -39,8 +39,8 @@
     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();
@@ -69,8 +69,8 @@
     }
 
     // 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) {
@@ -121,8 +121,8 @@
     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);
diff --git a/src/gpu/GrStrokeInfo.cpp b/src/gpu/GrStrokeInfo.cpp
index 0ad4179..03483af 100644
--- a/src/gpu/GrStrokeInfo.cpp
+++ b/src/gpu/GrStrokeInfo.cpp
@@ -36,9 +36,9 @@
         kCapShift = kJoinShift + kJoinBits,
     };
 
-    SK_COMPILE_ASSERT(SkStrokeRec::kStyleCount <= (1 << kStyleBits), style_shift_will_be_wrong);
-    SK_COMPILE_ASSERT(SkPaint::kJoinCount <= (1 << kJoinBits), cap_shift_will_be_wrong);
-    SK_COMPILE_ASSERT(SkPaint::kCapCount <= (1 << kCapBits), cap_does_not_fit);
+    static_assert(SkStrokeRec::kStyleCount <= (1 << kStyleBits), "style_shift_will_be_wrong");
+    static_assert(SkPaint::kJoinCount <= (1 << kJoinBits), "cap_shift_will_be_wrong");
+    static_assert(SkPaint::kCapCount <= (1 << kCapBits), "cap_does_not_fit");
     uint32_t styleKey = this->getStyle();
     if (this->needToApply()) {
         styleKey |= this->getJoin() << kJoinShift;
diff --git a/src/gpu/gl/GrGLPath.cpp b/src/gpu/gl/GrGLPath.cpp
index 0b35a70..9a4aa0c 100644
--- a/src/gpu/gl/GrGLPath.cpp
+++ b/src/gpu/gl/GrGLPath.cpp
@@ -105,7 +105,7 @@
 
         if ((skPath.getSegmentMasks() & SkPath::kConic_SegmentMask) == 0) {
             // This branch does type punning, converting SkPoint* to GrGLfloat*.
-            SK_COMPILE_ASSERT(sizeof(SkPoint) == sizeof(GrGLfloat) * 2, sk_point_not_two_floats);
+            static_assert(sizeof(SkPoint) == sizeof(GrGLfloat) * 2, "sk_point_not_two_floats");
             // This branch does not convert with SkScalarToFloat.
 #ifndef SK_SCALAR_IS_FLOAT
 #error Need SK_SCALAR_IS_FLOAT.
diff --git a/src/images/SkScaledBitmapSampler.cpp b/src/images/SkScaledBitmapSampler.cpp
index f79eb6f..1d8d98d 100644
--- a/src/images/SkScaledBitmapSampler.cpp
+++ b/src/images/SkScaledBitmapSampler.cpp
@@ -660,8 +660,8 @@
 
     // The jump between dst configs in the table
     static const int gProcDstConfigSpan = 5;
-    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gProcChoosers) == 5 * gProcDstConfigSpan,
-                      gProcs_has_the_wrong_number_of_entries);
+    static_assert(SK_ARRAY_COUNT(gProcChoosers) == 5 * gProcDstConfigSpan,
+                  "gProcs_has_the_wrong_number_of_entries");
 
     fCTable = ctable;
 
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index fa3bc4a..179e02b 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -353,17 +353,12 @@
 // enums so region_op_to_pathops_op can do a straight passthrough cast.
 // If these are failing, it may be necessary to make region_op_to_pathops_op
 // do more.
-SK_COMPILE_ASSERT(SkRegion::kDifference_Op == (int)kDifference_SkPathOp,
-                  region_pathop_mismatch);
-SK_COMPILE_ASSERT(SkRegion::kIntersect_Op == (int)kIntersect_SkPathOp,
-                  region_pathop_mismatch);
-SK_COMPILE_ASSERT(SkRegion::kUnion_Op == (int)kUnion_SkPathOp,
-                  region_pathop_mismatch);
-SK_COMPILE_ASSERT(SkRegion::kXOR_Op == (int)kXOR_SkPathOp,
-                  region_pathop_mismatch);
-SK_COMPILE_ASSERT(SkRegion::kReverseDifference_Op ==
-                  (int)kReverseDifference_SkPathOp,
-                  region_pathop_mismatch);
+static_assert(SkRegion::kDifference_Op == (int)kDifference_SkPathOp, "region_pathop_mismatch");
+static_assert(SkRegion::kIntersect_Op == (int)kIntersect_SkPathOp, "region_pathop_mismatch");
+static_assert(SkRegion::kUnion_Op == (int)kUnion_SkPathOp, "region_pathop_mismatch");
+static_assert(SkRegion::kXOR_Op == (int)kXOR_SkPathOp, "region_pathop_mismatch");
+static_assert(SkRegion::kReverseDifference_Op == (int)kReverseDifference_SkPathOp,
+              "region_pathop_mismatch");
 
 static SkPathOp region_op_to_pathops_op(SkRegion::Op op) {
     SkASSERT(op >= 0);
@@ -559,11 +554,9 @@
             currentEntry()->fTextScaleX = state.fTextScaleX;
         }
         if (state.fTextFill != currentEntry()->fTextFill) {
-            SK_COMPILE_ASSERT(SkPaint::kFill_Style == 0, enum_must_match_value);
-            SK_COMPILE_ASSERT(SkPaint::kStroke_Style == 1,
-                              enum_must_match_value);
-            SK_COMPILE_ASSERT(SkPaint::kStrokeAndFill_Style == 2,
-                              enum_must_match_value);
+            static_assert(SkPaint::kFill_Style == 0, "enum_must_match_value");
+            static_assert(SkPaint::kStroke_Style == 1, "enum_must_match_value");
+            static_assert(SkPaint::kStrokeAndFill_Style == 2, "enum_must_match_value");
             fContentStream->writeDecAsText(state.fTextFill);
             fContentStream->writeText(" Tr\n");
             currentEntry()->fTextFill = state.fTextFill;
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 017b016..17623c7 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -603,8 +603,7 @@
         unsigned char* subsetFont = NULL;
         // sfntly requires unsigned int* to be passed in, as far as we know,
         // unsigned int is equivalent to uint32_t on all platforms.
-        SK_COMPILE_ASSERT(sizeof(unsigned int) == sizeof(uint32_t),
-                          unsigned_int_not_32_bits);
+        static_assert(sizeof(unsigned int) == sizeof(uint32_t), "unsigned_int_not_32_bits");
         int subsetFontSize = SfntlyWrapper::SubsetFont(fontName,
                                                        originalFont.begin(),
                                                        fontSize,
diff --git a/src/pdf/SkPDFGraphicState.cpp b/src/pdf/SkPDFGraphicState.cpp
index 55f3b39..c4b6c20 100644
--- a/src/pdf/SkPDFGraphicState.cpp
+++ b/src/pdf/SkPDFGraphicState.cpp
@@ -210,17 +210,17 @@
     SkPaint::Join strokeJoin = (SkPaint::Join)fStrokeJoin;
     SkXfermode::Mode xferMode = (SkXfermode::Mode)fMode;
 
-    SK_COMPILE_ASSERT(SkPaint::kButt_Cap == 0, paint_cap_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kRound_Cap == 1, paint_cap_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kSquare_Cap == 2, paint_cap_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kCapCount == 3, paint_cap_mismatch);
+    static_assert(SkPaint::kButt_Cap == 0, "paint_cap_mismatch");
+    static_assert(SkPaint::kRound_Cap == 1, "paint_cap_mismatch");
+    static_assert(SkPaint::kSquare_Cap == 2, "paint_cap_mismatch");
+    static_assert(SkPaint::kCapCount == 3, "paint_cap_mismatch");
     SkASSERT(strokeCap >= 0 && strokeCap <= 2);
     dict->insertInt("LC", strokeCap);
 
-    SK_COMPILE_ASSERT(SkPaint::kMiter_Join == 0, paint_join_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kRound_Join == 1, paint_join_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kBevel_Join == 2, paint_join_mismatch);
-    SK_COMPILE_ASSERT(SkPaint::kJoinCount == 3, paint_join_mismatch);
+    static_assert(SkPaint::kMiter_Join == 0, "paint_join_mismatch");
+    static_assert(SkPaint::kRound_Join == 1, "paint_join_mismatch");
+    static_assert(SkPaint::kBevel_Join == 2, "paint_join_mismatch");
+    static_assert(SkPaint::kJoinCount == 3, "paint_join_mismatch");
     SkASSERT(strokeJoin >= 0 && strokeJoin <= 2);
     dict->insertInt("LJ", strokeJoin);
 
diff --git a/src/pdf/SkPDFResourceDict.cpp b/src/pdf/SkPDFResourceDict.cpp
index 1f5bcea..dbe733e 100644
--- a/src/pdf/SkPDFResourceDict.cpp
+++ b/src/pdf/SkPDFResourceDict.cpp
@@ -12,14 +12,10 @@
 // expected values as defined in the arrays below.
 // If these are failing, you may need to update the resource_type_prefixes
 // and resource_type_names arrays below.
-SK_COMPILE_ASSERT(SkPDFResourceDict::kExtGState_ResourceType == 0,
-                  resource_type_mismatch);
-SK_COMPILE_ASSERT(SkPDFResourceDict::kPattern_ResourceType == 1,
-                  resource_type_mismatch);
-SK_COMPILE_ASSERT(SkPDFResourceDict::kXObject_ResourceType == 2,
-                  resource_type_mismatch);
-SK_COMPILE_ASSERT(SkPDFResourceDict::kFont_ResourceType == 3,
-                  resource_type_mismatch);
+static_assert(SkPDFResourceDict::kExtGState_ResourceType == 0, "resource_type_mismatch");
+static_assert(SkPDFResourceDict::kPattern_ResourceType == 1, "resource_type_mismatch");
+static_assert(SkPDFResourceDict::kXObject_ResourceType == 2, "resource_type_mismatch");
+static_assert(SkPDFResourceDict::kFont_ResourceType == 3, "resource_type_mismatch");
 
 static const char resource_type_prefixes[] = {
         'G',
diff --git a/src/pdf/SkPDFTypes.h b/src/pdf/SkPDFTypes.h
index 23a30b9..56e534b 100644
--- a/src/pdf/SkPDFTypes.h
+++ b/src/pdf/SkPDFTypes.h
@@ -158,7 +158,7 @@
     SkPDFUnion& operator=(const SkPDFUnion&) = delete;
     SkPDFUnion(const SkPDFUnion&) = delete;
 };
-SK_COMPILE_ASSERT(sizeof(SkString) == sizeof(void*), SkString_size);
+static_assert(sizeof(SkString) == sizeof(void*), "SkString_size");
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index e45a485..d19ab1a 100755
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -1855,7 +1855,7 @@
 //Length of GUID representation from create_id, including NULL terminator.
 #define BASE64_GUID_ID_LEN SK_ARRAY_COUNT(BASE64_GUID_ID)
 
-SK_COMPILE_ASSERT(BASE64_GUID_ID_LEN < LF_FACESIZE, GUID_longer_than_facesize);
+static_assert(BASE64_GUID_ID_LEN < LF_FACESIZE, "GUID_longer_than_facesize");
 
 /**
    NameID 6 Postscript names cannot have the character '/'.
diff --git a/src/ports/SkFontMgr_android_parser.h b/src/ports/SkFontMgr_android_parser.h
index 175a6fa..ca66c43 100644
--- a/src/ports/SkFontMgr_android_parser.h
+++ b/src/ports/SkFontMgr_android_parser.h
@@ -126,7 +126,7 @@
  *  If the string cannot be parsed into 'value', returns false and does not change 'value'.
  */
 template <typename T> static bool parse_non_negative_integer(const char* s, T* value) {
-    SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer);
+    static_assert(std::numeric_limits<T>::is_integer, "T_must_be_integer");
 
     if (*s == '\0') {
         return false;
@@ -163,9 +163,9 @@
  *  If the string cannot be parsed into 'value', returns false and does not change 'value'.
  */
 template <int N, typename T> static bool parse_fixed(const char* s, T* value) {
-    SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer);
-    SK_COMPILE_ASSERT(std::numeric_limits<T>::is_signed, T_must_be_signed);
-    SK_COMPILE_ASSERT(sizeof(T) * CHAR_BIT - N >= 5, N_must_leave_four_bits_plus_sign);
+    static_assert(std::numeric_limits<T>::is_integer, "T_must_be_integer");
+    static_assert(std::numeric_limits<T>::is_signed, "T_must_be_signed");
+    static_assert(sizeof(T) * CHAR_BIT - N >= 5, "N_must_leave_four_bits_plus_sign");
 
     bool negate = false;
     if (*s == '-') {
diff --git a/src/ports/SkFontMgr_fontconfig.cpp b/src/ports/SkFontMgr_fontconfig.cpp
index e98bd01..5a34455 100644
--- a/src/ports/SkFontMgr_fontconfig.cpp
+++ b/src/ports/SkFontMgr_fontconfig.cpp
@@ -301,7 +301,7 @@
 }
 
 template<int n> struct SkTFixed {
-    SK_COMPILE_ASSERT(-32768 <= n && n <= 32767, SkTFixed_n_not_in_range);
+    static_assert(-32768 <= n && n <= 32767, "SkTFixed_n_not_in_range");
     static const SkFixed value = static_cast<SkFixed>(n << 16);
 };
 
diff --git a/src/ports/SkOSFile_posix.cpp b/src/ports/SkOSFile_posix.cpp
index 6f64478..b7cf583 100644
--- a/src/ports/SkOSFile_posix.cpp
+++ b/src/ports/SkOSFile_posix.cpp
@@ -102,7 +102,7 @@
     DIR* fDIR;
     SkString fPath, fSuffix;
 };
-SK_COMPILE_ASSERT(sizeof(SkOSFileIterData) <= SkOSFile::Iter::kStorageSize, not_enough_space);
+static_assert(sizeof(SkOSFileIterData) <= SkOSFile::Iter::kStorageSize, "not_enough_space");
 
 SkOSFile::Iter::Iter() {
     SkNEW_PLACEMENT(fSelf.get(), SkOSFileIterData);
diff --git a/src/ports/SkOSFile_win.cpp b/src/ports/SkOSFile_win.cpp
index a544168..62510e7 100644
--- a/src/ports/SkOSFile_win.cpp
+++ b/src/ports/SkOSFile_win.cpp
@@ -128,7 +128,7 @@
     HANDLE fHandle;
     uint16_t* fPath16;
 };
-SK_COMPILE_ASSERT(sizeof(SkOSFileIterData) <= SkOSFile::Iter::kStorageSize, not_enough_space);
+static_assert(sizeof(SkOSFileIterData) <= SkOSFile::Iter::kStorageSize, "not_enough_space");
 
 static uint16_t* concat_to_16(const char src[], const char suffix[]) {
     size_t  i, len = strlen(src);
diff --git a/src/sfnt/SkIBMFamilyClass.h b/src/sfnt/SkIBMFamilyClass.h
index 45d9822..1572011 100644
--- a/src/sfnt/SkIBMFamilyClass.h
+++ b/src/sfnt/SkIBMFamilyClass.h
@@ -169,6 +169,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkIBMFamilyClass) == 2, sizeof_SkIBMFamilyClass_not_2);
+static_assert(sizeof(SkIBMFamilyClass) == 2, "sizeof_SkIBMFamilyClass_not_2");
 
 #endif
diff --git a/src/sfnt/SkOTTableTypes.h b/src/sfnt/SkOTTableTypes.h
index fa76b20..119f17e 100644
--- a/src/sfnt/SkOTTableTypes.h
+++ b/src/sfnt/SkOTTableTypes.h
@@ -47,14 +47,14 @@
 
 /** SkOTSetUSHORTBit<N>::value is an SK_OT_USHORT with the Nth BE bit set. */
 template <unsigned N> struct SkOTSetUSHORTBit {
-    SK_COMPILE_ASSERT(N < 16, NTooBig);
+    static_assert(N < 16, "NTooBig");
     static const uint16_t bit = 1u << N;
     static const SK_OT_USHORT value = SkTEndian_SwapBE16(bit);
 };
 
 /** SkOTSetULONGBit<N>::value is an SK_OT_ULONG with the Nth BE bit set. */
 template <unsigned N> struct SkOTSetULONGBit {
-    SK_COMPILE_ASSERT(N < 32, NTooBig);
+    static_assert(N < 32, "NTooBig");
     static const uint32_t bit = 1u << N;
     static const SK_OT_ULONG value = SkTEndian_SwapBE32(bit);
 };
diff --git a/src/sfnt/SkOTTable_OS_2.h b/src/sfnt/SkOTTable_OS_2.h
index c4dbc53..4a09a78 100644
--- a/src/sfnt/SkOTTable_OS_2.h
+++ b/src/sfnt/SkOTTable_OS_2.h
@@ -42,11 +42,11 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::VA) == 68, sizeof_SkOTTableOS2__VA_not_68);
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::V0) == 78, sizeof_SkOTTableOS2__V0_not_78);
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::V1) == 86, sizeof_SkOTTableOS2__V1_not_86);
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::V2) == 96, sizeof_SkOTTableOS2__V2_not_96);
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::V3) == 96, sizeof_SkOTTableOS2__V3_not_96);
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2::Version::V4) == 96, sizeof_SkOTTableOS2__V4_not_96);
+static_assert(sizeof(SkOTTableOS2::Version::VA) == 68, "sizeof_SkOTTableOS2__VA_not_68");
+static_assert(sizeof(SkOTTableOS2::Version::V0) == 78, "sizeof_SkOTTableOS2__V0_not_78");
+static_assert(sizeof(SkOTTableOS2::Version::V1) == 86, "sizeof_SkOTTableOS2__V1_not_86");
+static_assert(sizeof(SkOTTableOS2::Version::V2) == 96, "sizeof_SkOTTableOS2__V2_not_96");
+static_assert(sizeof(SkOTTableOS2::Version::V3) == 96, "sizeof_SkOTTableOS2__V3_not_96");
+static_assert(sizeof(SkOTTableOS2::Version::V4) == 96, "sizeof_SkOTTableOS2__V4_not_96");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_V0.h b/src/sfnt/SkOTTable_OS_2_V0.h
index b65bcf7..4dff413 100644
--- a/src/sfnt/SkOTTable_OS_2_V0.h
+++ b/src/sfnt/SkOTTable_OS_2_V0.h
@@ -144,6 +144,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_V0) == 78, sizeof_SkOTTableOS2_V0_not_78);
+static_assert(sizeof(SkOTTableOS2_V0) == 78, "sizeof_SkOTTableOS2_V0_not_78");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_V1.h b/src/sfnt/SkOTTable_OS_2_V1.h
index e53c0e6..43e61d4 100644
--- a/src/sfnt/SkOTTable_OS_2_V1.h
+++ b/src/sfnt/SkOTTable_OS_2_V1.h
@@ -513,6 +513,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_V1) == 86, sizeof_SkOTTableOS2_V1_not_86);
+static_assert(sizeof(SkOTTableOS2_V1) == 86, "sizeof_SkOTTableOS2_V1_not_86");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_V2.h b/src/sfnt/SkOTTable_OS_2_V2.h
index 52f9460..30ad016 100644
--- a/src/sfnt/SkOTTable_OS_2_V2.h
+++ b/src/sfnt/SkOTTable_OS_2_V2.h
@@ -535,6 +535,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_V2) == 96, sizeof_SkOTTableOS2_V2_not_96);
+static_assert(sizeof(SkOTTableOS2_V2) == 96, "sizeof_SkOTTableOS2_V2_not_96");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_V3.h b/src/sfnt/SkOTTable_OS_2_V3.h
index 8d4fa6b..00df289 100644
--- a/src/sfnt/SkOTTable_OS_2_V3.h
+++ b/src/sfnt/SkOTTable_OS_2_V3.h
@@ -545,6 +545,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_V3) == 96, sizeof_SkOTTableOS2_V3_not_96);
+static_assert(sizeof(SkOTTableOS2_V3) == 96, "sizeof_SkOTTableOS2_V3_not_96");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_V4.h b/src/sfnt/SkOTTable_OS_2_V4.h
index fc64b22..3d22a1b 100644
--- a/src/sfnt/SkOTTable_OS_2_V4.h
+++ b/src/sfnt/SkOTTable_OS_2_V4.h
@@ -580,6 +580,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_V4) == 96, sizeof_SkOTTableOS2_V4_not_96);
+static_assert(sizeof(SkOTTableOS2_V4) == 96, "sizeof_SkOTTableOS2_V4_not_96");
 
 #endif
diff --git a/src/sfnt/SkOTTable_OS_2_VA.h b/src/sfnt/SkOTTable_OS_2_VA.h
index bc45da2..1dc95b5 100644
--- a/src/sfnt/SkOTTable_OS_2_VA.h
+++ b/src/sfnt/SkOTTable_OS_2_VA.h
@@ -137,6 +137,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableOS2_VA) == 68, sizeof_SkOTTableOS2_VA_not_68);
+static_assert(sizeof(SkOTTableOS2_VA) == 68, "sizeof_SkOTTableOS2_VA_not_68");
 
 #endif
diff --git a/src/sfnt/SkOTTable_gasp.h b/src/sfnt/SkOTTable_gasp.h
index ca2d265..c6d8aa6 100644
--- a/src/sfnt/SkOTTable_gasp.h
+++ b/src/sfnt/SkOTTable_gasp.h
@@ -67,7 +67,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTableGridAndScanProcedure, numRanges) == 2, SkOTTableGridAndScanProcedure_numRanges_not_at_2);
-SK_COMPILE_ASSERT(sizeof(SkOTTableGridAndScanProcedure) == 4, sizeof_SkOTTableGridAndScanProcedure_not_4);
+static_assert(offsetof(SkOTTableGridAndScanProcedure, numRanges) == 2, "SkOTTableGridAndScanProcedure_numRanges_not_at_2");
+static_assert(sizeof(SkOTTableGridAndScanProcedure) == 4, "sizeof_SkOTTableGridAndScanProcedure_not_4");
 
 #endif
diff --git a/src/sfnt/SkOTTable_head.h b/src/sfnt/SkOTTable_head.h
index 3d2c0f1..52970b0 100644
--- a/src/sfnt/SkOTTable_head.h
+++ b/src/sfnt/SkOTTable_head.h
@@ -144,7 +144,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTableHead, glyphDataFormat) == 52, SkOTTableHead_glyphDataFormat_not_at_52);
-SK_COMPILE_ASSERT(sizeof(SkOTTableHead) == 54, sizeof_SkOTTableHead_not_54);
+static_assert(offsetof(SkOTTableHead, glyphDataFormat) == 52, "SkOTTableHead_glyphDataFormat_not_at_52");
+static_assert(sizeof(SkOTTableHead) == 54, "sizeof_SkOTTableHead_not_54");
 
 #endif
diff --git a/src/sfnt/SkOTTable_hhea.h b/src/sfnt/SkOTTable_hhea.h
index b8a2070..a3b9cad 100644
--- a/src/sfnt/SkOTTable_hhea.h
+++ b/src/sfnt/SkOTTable_hhea.h
@@ -50,7 +50,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTableHorizontalHeader, numberOfHMetrics) == 34, SkOTTableHorizontalHeader_numberOfHMetrics_not_at_34);
-SK_COMPILE_ASSERT(sizeof(SkOTTableHorizontalHeader) == 36, sizeof_SkOTTableHorizontalHeader_not_36);
+static_assert(offsetof(SkOTTableHorizontalHeader, numberOfHMetrics) == 34, "SkOTTableHorizontalHeader_numberOfHMetrics_not_at_34");
+static_assert(sizeof(SkOTTableHorizontalHeader) == 36, "sizeof_SkOTTableHorizontalHeader_not_36");
 
 #endif
diff --git a/src/sfnt/SkOTTable_maxp_CFF.h b/src/sfnt/SkOTTable_maxp_CFF.h
index f97bff9..435d823 100644
--- a/src/sfnt/SkOTTable_maxp_CFF.h
+++ b/src/sfnt/SkOTTable_maxp_CFF.h
@@ -24,7 +24,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTableMaximumProfile_CFF, numGlyphs) == 4, SkOTTableMaximumProfile_CFF_numGlyphs_not_at_4);
-SK_COMPILE_ASSERT(sizeof(SkOTTableMaximumProfile_CFF) == 6, sizeof_SkOTTableMaximumProfile_CFF_not_6);
+static_assert(offsetof(SkOTTableMaximumProfile_CFF, numGlyphs) == 4, "SkOTTableMaximumProfile_CFF_numGlyphs_not_at_4");
+static_assert(sizeof(SkOTTableMaximumProfile_CFF) == 6, "sizeof_SkOTTableMaximumProfile_CFF_not_6");
 
 #endif
diff --git a/src/sfnt/SkOTTable_maxp_TT.h b/src/sfnt/SkOTTable_maxp_TT.h
index 9aa557f..1fdd0ed 100644
--- a/src/sfnt/SkOTTable_maxp_TT.h
+++ b/src/sfnt/SkOTTable_maxp_TT.h
@@ -44,7 +44,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTableMaximumProfile_TT, maxComponentDepth) == 30, SkOTTableMaximumProfile_TT_maxComponentDepth_not_at_30);
-SK_COMPILE_ASSERT(sizeof(SkOTTableMaximumProfile_TT) == 32, sizeof_SkOTTableMaximumProfile_TT_not_32);
+static_assert(offsetof(SkOTTableMaximumProfile_TT, maxComponentDepth) == 30, "SkOTTableMaximumProfile_TT_maxComponentDepth_not_at_30");
+static_assert(sizeof(SkOTTableMaximumProfile_TT) == 32, "sizeof_SkOTTableMaximumProfile_TT_not_32");
 
 #endif
diff --git a/src/sfnt/SkOTTable_name.h b/src/sfnt/SkOTTable_name.h
index ab38d72..6b25a2d 100644
--- a/src/sfnt/SkOTTable_name.h
+++ b/src/sfnt/SkOTTable_name.h
@@ -576,9 +576,9 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkOTTableName) == 6, sizeof_SkOTTableName_not_6);
-SK_COMPILE_ASSERT(sizeof(SkOTTableName::Format1Ext) == 2, sizeof_SkOTTableNameF1_not_2);
-SK_COMPILE_ASSERT(sizeof(SkOTTableName::Format1Ext::LangTagRecord) == 4, sizeof_SkOTTableNameLangTagRecord_not_4);
-SK_COMPILE_ASSERT(sizeof(SkOTTableName::Record) == 12, sizeof_SkOTTableNameRecord_not_12);
+static_assert(sizeof(SkOTTableName) == 6, "sizeof_SkOTTableName_not_6");
+static_assert(sizeof(SkOTTableName::Format1Ext) == 2, "sizeof_SkOTTableNameF1_not_2");
+static_assert(sizeof(SkOTTableName::Format1Ext::LangTagRecord) == 4, "sizeof_SkOTTableNameLangTagRecord_not_4");
+static_assert(sizeof(SkOTTableName::Record) == 12, "sizeof_SkOTTableNameRecord_not_12");
 
 #endif
diff --git a/src/sfnt/SkOTTable_post.h b/src/sfnt/SkOTTable_post.h
index f563b08..7461d52 100644
--- a/src/sfnt/SkOTTable_post.h
+++ b/src/sfnt/SkOTTable_post.h
@@ -46,7 +46,7 @@
 
 
 #include <stddef.h>
-SK_COMPILE_ASSERT(offsetof(SkOTTablePostScript, maxMemType1) == 28, SkOTTablePostScript_maxMemType1_not_at_28);
-SK_COMPILE_ASSERT(sizeof(SkOTTablePostScript) == 32, sizeof_SkOTTablePostScript_not_32);
+static_assert(offsetof(SkOTTablePostScript, maxMemType1) == 28, "SkOTTablePostScript_maxMemType1_not_at_28");
+static_assert(sizeof(SkOTTablePostScript) == 32, "sizeof_SkOTTablePostScript_not_32");
 
 #endif
diff --git a/src/sfnt/SkPanose.h b/src/sfnt/SkPanose.h
index 873c093..9561e56 100644
--- a/src/sfnt/SkPanose.h
+++ b/src/sfnt/SkPanose.h
@@ -634,6 +634,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkPanose) == 10, sizeof_SkPanose_not_10);
+static_assert(sizeof(SkPanose) == 10, "sizeof_SkPanose_not_10");
 
 #endif
diff --git a/src/sfnt/SkSFNTHeader.h b/src/sfnt/SkSFNTHeader.h
index 9071696..c2ea1e0 100644
--- a/src/sfnt/SkSFNTHeader.h
+++ b/src/sfnt/SkSFNTHeader.h
@@ -64,7 +64,7 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkSFNTHeader) == 12, sizeof_SkSFNTHeader_not_12);
-SK_COMPILE_ASSERT(sizeof(SkSFNTHeader::TableDirectoryEntry) == 16, sizeof_SkSFNTHeader_TableDirectoryEntry_not_16);
+static_assert(sizeof(SkSFNTHeader) == 12, "sizeof_SkSFNTHeader_not_12");
+static_assert(sizeof(SkSFNTHeader::TableDirectoryEntry) == 16, "sizeof_SkSFNTHeader_TableDirectoryEntry_not_16");
 
 #endif
diff --git a/src/sfnt/SkTTCFHeader.h b/src/sfnt/SkTTCFHeader.h
index 8f53c03..2dc77ee 100644
--- a/src/sfnt/SkTTCFHeader.h
+++ b/src/sfnt/SkTTCFHeader.h
@@ -51,6 +51,6 @@
 #pragma pack(pop)
 
 
-SK_COMPILE_ASSERT(sizeof(SkTTCFHeader) == 12, sizeof_SkTTCFHeader_not_12);
+static_assert(sizeof(SkTTCFHeader) == 12, "sizeof_SkTTCFHeader_not_12");
 
 #endif
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index 9fd7ce7..64f74c8 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -42,7 +42,7 @@
     "round", // kRound_Cap
     "square" // kSquare_Cap
 };
-SK_COMPILE_ASSERT(SK_ARRAY_COUNT(cap_map) == SkPaint::kCapCount, missing_cap_map_entry);
+static_assert(SK_ARRAY_COUNT(cap_map) == SkPaint::kCapCount, "missing_cap_map_entry");
 
 static const char* svg_cap(SkPaint::Cap cap) {
     SkASSERT(cap < SK_ARRAY_COUNT(cap_map));
@@ -55,7 +55,7 @@
     "round", // kRound_Join
     "bevel"  // kBevel_Join
 };
-SK_COMPILE_ASSERT(SK_ARRAY_COUNT(join_map) == SkPaint::kJoinCount, missing_join_map_entry);
+static_assert(SK_ARRAY_COUNT(join_map) == SkPaint::kJoinCount, "missing_join_map_entry");
 
 static const char* svg_join(SkPaint::Join join) {
     SkASSERT(join < SK_ARRAY_COUNT(join_map));
@@ -68,8 +68,8 @@
     "middle", // kCenter_Align
     "end"     // kRight_Align
 };
-SK_COMPILE_ASSERT(SK_ARRAY_COUNT(text_align_map) == SkPaint::kAlignCount,
-                  missing_text_align_map_entry);
+static_assert(SK_ARRAY_COUNT(text_align_map) == SkPaint::kAlignCount,
+              "missing_text_align_map_entry");
 static const char* svg_text_align(SkPaint::Align align) {
     SkASSERT(align < SK_ARRAY_COUNT(text_align_map));
     return text_align_map[align];
diff --git a/src/utils/SkTFitsIn.h b/src/utils/SkTFitsIn.h
index 1d04981..bbc22d4 100644
--- a/src/utils/SkTFitsIn.h
+++ b/src/utils/SkTFitsIn.h
@@ -39,7 +39,7 @@
     typedef S source_type;
     static bool apply(S s) {
         typedef typename SkTHasMoreDigits<S, D>::type precondition;
-        SK_COMPILE_ASSERT(precondition::value, SkTOutOfRange_LT_MinD__minS_gt_minD);
+        static_assert(precondition::value, "SkTOutOfRange_LT_MinD__minS_gt_minD");
 
         return s < static_cast<S>((std::numeric_limits<D>::min)());
     }
@@ -62,7 +62,7 @@
     typedef S source_type;
     static bool apply(S s) {
         typedef typename SkTHasMoreDigits<S, D>::type precondition;
-        SK_COMPILE_ASSERT(precondition::value, SkTOutOfRange_GT_MaxD__maxS_lt_maxD);
+        static_assert(precondition::value, "SkTOutOfRange_GT_MaxD__maxS_lt_maxD");
 
         return s > static_cast<S>((std::numeric_limits<D>::max)());
     }
@@ -200,8 +200,8 @@
 
 /** Returns true if the integer source value 's' will fit in the integer destination type 'D'. */
 template <typename D, typename S> inline bool SkTFitsIn(S s) {
-    SK_COMPILE_ASSERT(std::numeric_limits<S>::is_integer, SkTFitsIn_source_must_be_integer);
-    SK_COMPILE_ASSERT(std::numeric_limits<D>::is_integer, SkTFitsIn_destination_must_be_integer);
+    static_assert(std::numeric_limits<S>::is_integer, "SkTFitsIn_source_must_be_integer");
+    static_assert(std::numeric_limits<D>::is_integer, "SkTFitsIn_destination_must_be_integer");
 
     return !sktfitsin::Private::SkTFitsIn<D, S>::type::OutOfRange(s);
 }
diff --git a/src/views/mac/SkNSView.mm b/src/views/mac/SkNSView.mm
index fd26e8a..a8376e6 100644
--- a/src/views/mac/SkNSView.mm
+++ b/src/views/mac/SkNSView.mm
@@ -10,7 +10,7 @@
 #include "SkSurface.h"
 #include "SkCGUtils.h"
 #include "SkEvent.h"
-SK_COMPILE_ASSERT(SK_SUPPORT_GPU, not_implemented_for_non_gpu_build);
+static_assert(SK_SUPPORT_GPU, "not_implemented_for_non_gpu_build");
 #include <OpenGL/gl.h>
 
 //#define FORCE_REDRAW
diff --git a/src/views/mac/SkOSWindow_Mac.mm b/src/views/mac/SkOSWindow_Mac.mm
index 2b11ffc..9dbbe5b 100644
--- a/src/views/mac/SkOSWindow_Mac.mm
+++ b/src/views/mac/SkOSWindow_Mac.mm
@@ -16,7 +16,7 @@
 #import  "SkEventNotifier.h"
 #define  kINVAL_NSVIEW_EventType "inval-nsview"
 
-SK_COMPILE_ASSERT(SK_SUPPORT_GPU, not_implemented_for_non_gpu_build);
+static_assert(SK_SUPPORT_GPU, "not_implemented_for_non_gpu_build");
 
 SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd) {
     fInvalEventIsPending = false;