Remove most of GrConfig.h
Change-Id: I0f693bed0778151f93d07cd42c6b597566695ab1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/257999
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp
index 7bc7bdb..6aad014 100644
--- a/gm/constcolorprocessor.cpp
+++ b/gm/constcolorprocessor.cpp
@@ -89,7 +89,7 @@
"kModulateRGBA",
"kModulateA",
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kModeStrs) == GrConstColorProcessor::kInputModeCnt);
+ static_assert(SK_ARRAY_COUNT(kModeStrs) == GrConstColorProcessor::kInputModeCnt);
SkScalar y = kPad;
SkScalar x = kPad;
diff --git a/gm/wacky_yuv_formats.cpp b/gm/wacky_yuv_formats.cpp
index 4607a54..038921c 100644
--- a/gm/wacky_yuv_formats.cpp
+++ b/gm/wacky_yuv_formats.cpp
@@ -919,7 +919,7 @@
static void draw_col_label(SkCanvas* canvas, int x, int yuvColorSpace, bool opaque) {
static const char* kYUVColorSpaceNames[] = { "JPEG", "601", "709", "2020", "Identity" };
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kYUVColorSpaceNames) == kLastEnum_SkYUVColorSpace+1);
+ static_assert(SK_ARRAY_COUNT(kYUVColorSpaceNames) == kLastEnum_SkYUVColorSpace + 1);
SkPaint paint;
SkFont font(ToolUtils::create_portable_typeface(nullptr, SkFontStyle::Bold()), 16);
@@ -946,7 +946,7 @@
static const char* kYUVFormatNames[] = {
"P016", "P010", "P016F", "Y416", "AYUV", "Y410", "NV12", "NV21", "I420", "YV12"
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kYUVFormatNames) == kLast_YUVFormat+1);
+ static_assert(SK_ARRAY_COUNT(kYUVFormatNames) == kLast_YUVFormat + 1);
SkPaint paint;
SkFont font(ToolUtils::create_portable_typeface(nullptr, SkFontStyle::Bold()), 16);
diff --git a/include/gpu/GrConfig.h b/include/gpu/GrConfig.h
index 3daae61..858d33a 100644
--- a/include/gpu/GrConfig.h
+++ b/include/gpu/GrConfig.h
@@ -6,28 +6,11 @@
* found in the LICENSE file.
*/
-
-
#ifndef GrConfig_DEFINED
#define GrConfig_DEFINED
#include "include/core/SkTypes.h"
-///////////////////////////////////////////////////////////////////////////////
-// preconfig section:
-//
-// All the work before including GrUserConfig.h should center around guessing
-// what platform we're on, and defining low-level symbols based on that.
-//
-// A build environment may have already defined symbols, so we first check
-// for that
-//
-
-// hack to ensure we know what sort of Apple platform we're on
-#if defined(__APPLE_CPP__) || defined(__APPLE_CC__)
- #include <TargetConditionals.h>
-#endif
-
/**
* Gr defines are set to 0 or 1, rather than being undefined or defined
*/
@@ -48,26 +31,7 @@
#endif
#endif
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-/*
- * Include stdint.h with defines that trigger declaration of C99 limit/const
- * macros here before anyone else has a chance to include stdint.h without
- * these.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS
#endif
-#ifndef __STDC_CONSTANT_MACROS
-#define __STDC_CONSTANT_MACROS
-#endif
-#include <stdint.h>
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// postconfig section:
-//
/**
* GR_STRING makes a string of X where X is expanded before conversion to a string
@@ -87,78 +51,3 @@
* Creates a string of the form "<filename>(<linenumber>) : "
*/
#define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "
-
-/**
- * Compilers have different ways of issuing warnings. This macro
- * attempts to abstract them, but may need to be specialized for your
- * particular compiler.
- * To insert compiler warnings use "#pragma message GR_WARN(<string>)"
- */
-#if defined(_MSC_VER)
- #define GR_WARN(MSG) (GR_FILE_AND_LINE_STR "WARNING: " MSG)
-#else//__GNUC__ - may need other defines for different compilers
- #define GR_WARN(MSG) ("WARNING: " MSG)
-#endif
-
-/**
- * GR_ALWAYSBREAK is an unconditional break in all builds.
- */
-#if !defined(GR_ALWAYSBREAK)
- #if defined(SK_BUILD_FOR_WIN)
- #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); __debugbreak()
- #else
- // TODO: do other platforms really not have continuable breakpoints?
- // sign extend for 64bit architectures to be sure this is
- // in the high address range
- #define GR_ALWAYSBREAK SkNO_RETURN_HINT(); *((int*)(int64_t)(int32_t)0xbeefcafe) = 0;
- #endif
-#endif
-
-/**
- * GR_DEBUGBREAK is an unconditional break in debug builds.
- */
-#if !defined(GR_DEBUGBREAK)
- #ifdef SK_DEBUG
- #define GR_DEBUGBREAK GR_ALWAYSBREAK
- #else
- #define GR_DEBUGBREAK
- #endif
-#endif
-
-/**
- * GR_ALWAYSASSERT is an assertion in all builds.
- */
-#if !defined(GR_ALWAYSASSERT)
- #define GR_ALWAYSASSERT(COND) \
- do { \
- if (!(COND)) { \
- SkDebugf("%s %s failed\n", GR_FILE_AND_LINE_STR, #COND); \
- GR_ALWAYSBREAK; \
- } \
- } while (false)
-#endif
-
-/**
- * GR_DEBUGASSERT is an assertion in debug builds only.
- */
-#if !defined(GR_DEBUGASSERT)
- #ifdef SK_DEBUG
- #define GR_DEBUGASSERT(COND) GR_ALWAYSASSERT(COND)
- #else
- #define GR_DEBUGASSERT(COND)
- #endif
-#endif
-
-/**
- * Prettier forms of the above macros.
- */
-#define GrAlwaysAssert(COND) GR_ALWAYSASSERT(COND)
-
-/**
- * GR_STATIC_ASSERT is a compile time assertion. Depending on the platform
- * it may print the message in the compiler log. Obviously, the condition must
- * be evaluatable at compile time.
- */
-#define GR_STATIC_ASSERT(CONDITION) static_assert(CONDITION, "bug")
-
-#endif
diff --git a/include/gpu/gl/GrGLTypes.h b/include/gpu/gl/GrGLTypes.h
index 1dba115..9302ab6 100644
--- a/include/gpu/gl/GrGLTypes.h
+++ b/include/gpu/gl/GrGLTypes.h
@@ -123,7 +123,8 @@
GrGLuint fBaseInstance; // Requires EXT_base_instance on ES.
};
-GR_STATIC_ASSERT(16 == sizeof(GrGLDrawArraysIndirectCommand));
+// static_asserts must have messages in this file because its included in C++14 client code.
+static_assert(16 == sizeof(GrGLDrawArraysIndirectCommand), "");
struct GrGLDrawElementsIndirectCommand {
GrGLuint fCount;
@@ -133,7 +134,7 @@
GrGLuint fBaseInstance; // Requires EXT_base_instance on ES.
};
-GR_STATIC_ASSERT(20 == sizeof(GrGLDrawElementsIndirectCommand));
+static_assert(20 == sizeof(GrGLDrawElementsIndirectCommand), "");
/**
* KHR_debug
diff --git a/include/private/GrResourceKey.h b/include/private/GrResourceKey.h
index d67fa7d..7ad0bfd 100644
--- a/include/private/GrResourceKey.h
+++ b/include/private/GrResourceKey.h
@@ -43,7 +43,6 @@
/** Reset to an invalid key. */
void reset() {
- GR_STATIC_ASSERT((uint16_t)kInvalidDomain == kInvalidDomain);
fKey.reset(kMetaDataCnt);
fKey[kHash_MetaDataIdx] = 0;
fKey[kDomainAndSize_MetaDataIdx] = kInvalidDomain;
@@ -118,7 +117,6 @@
if (nullptr == fKey) {
return;
}
- GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
uint32_t* hash = &fKey->fKey[kHash_MetaDataIdx];
*hash = GrResourceKeyHash(hash + 1, fKey->internalSize() - sizeof(uint32_t));
fKey->validate();
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 9dd0f16..a86a5b6 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -54,9 +54,6 @@
#define RETURN_ON_NULL(ptr) do { if (nullptr == (ptr)) return; } while (0)
#define RETURN_ON_FALSE(pred) do { if (!(pred)) return; } while (0)
-// This is a test: static_assert with no message is a c++17 feature.
-static_assert(true);
-
///////////////////////////////////////////////////////////////////////////////////////////////////
/*
diff --git a/src/effects/imagefilters/SkLightingImageFilter.cpp b/src/effects/imagefilters/SkLightingImageFilter.cpp
index e18e7ab..8e3cfbd 100644
--- a/src/effects/imagefilters/SkLightingImageFilter.cpp
+++ b/src/effects/imagefilters/SkLightingImageFilter.cpp
@@ -49,7 +49,7 @@
#if SK_SUPPORT_GPU
static void setUniformPoint3(const GrGLSLProgramDataManager& pdman, UniformHandle uni,
const SkPoint3& point) {
- GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(float));
+ static_assert(sizeof(SkPoint3) == 3 * sizeof(float));
pdman.set3fv(uni, 1, &point.fX);
}
diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp
index 48dc58c..019420b 100644
--- a/src/gpu/GrCaps.cpp
+++ b/src/gpu/GrCaps.cpp
@@ -237,10 +237,10 @@
"Advanced",
"Advanced Coherent",
};
- GR_STATIC_ASSERT(0 == kBasic_BlendEquationSupport);
- GR_STATIC_ASSERT(1 == kAdvanced_BlendEquationSupport);
- GR_STATIC_ASSERT(2 == kAdvancedCoherent_BlendEquationSupport);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kBlendEquationSupportNames) == kLast_BlendEquationSupport + 1);
+ static_assert(0 == kBasic_BlendEquationSupport);
+ static_assert(1 == kAdvanced_BlendEquationSupport);
+ static_assert(2 == kAdvancedCoherent_BlendEquationSupport);
+ static_assert(SK_ARRAY_COUNT(kBlendEquationSupportNames) == kLast_BlendEquationSupport + 1);
writer->appendString("Blend Equation Support",
kBlendEquationSupportNames[fBlendEquationSupport]);
diff --git a/src/gpu/GrCaps.h b/src/gpu/GrCaps.h
index 49fdf70..dfafbde 100644
--- a/src/gpu/GrCaps.h
+++ b/src/gpu/GrCaps.h
@@ -524,7 +524,7 @@
BlendEquationSupport fBlendEquationSupport;
uint32_t fAdvBlendEqBlacklist;
- GR_STATIC_ASSERT(kLast_GrBlendEquation < 32);
+ static_assert(kLast_GrBlendEquation < 32);
uint32_t fMapBufferFlags;
int fBufferMapThreshold;
diff --git a/src/gpu/GrDistanceFieldGenFromVector.cpp b/src/gpu/GrDistanceFieldGenFromVector.cpp
index 11e375c..003e203 100644
--- a/src/gpu/GrDistanceFieldGenFromVector.cpp
+++ b/src/gpu/GrDistanceFieldGenFromVector.cpp
@@ -230,12 +230,12 @@
void init();
int countPoints() {
- GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
+ static_assert(0 == kLine && 1 == kQuad);
return fType + 2;
}
const SkPoint& endPt() const {
- GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
+ static_assert(0 == kLine && 1 == kQuad);
return fPts[fType + 1];
}
};
diff --git a/src/gpu/GrMesh.h b/src/gpu/GrMesh.h
index 08daf0e..e2f9713 100644
--- a/src/gpu/GrMesh.h
+++ b/src/gpu/GrMesh.h
@@ -87,8 +87,8 @@
};
GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
- GR_STATIC_ASSERT(Flags(GrPrimitiveRestart::kNo) == Flags::kNone);
- GR_STATIC_ASSERT(Flags(GrPrimitiveRestart::kYes) == Flags::kUsePrimitiveRestart);
+ static_assert(Flags(GrPrimitiveRestart::kNo) == Flags::kNone);
+ static_assert(Flags(GrPrimitiveRestart::kYes) == Flags::kUsePrimitiveRestart);
GrPrimitiveType fPrimitiveType;
sk_sp<const GrBuffer> fIndexBuffer;
diff --git a/src/gpu/GrNativeRect.h b/src/gpu/GrNativeRect.h
index 24b5b25..9b90134 100644
--- a/src/gpu/GrNativeRect.h
+++ b/src/gpu/GrNativeRect.h
@@ -41,11 +41,11 @@
const int* asInts() const {
return &fX;
- GR_STATIC_ASSERT(0 == offsetof(GrNativeRect, fX));
- GR_STATIC_ASSERT(4 == offsetof(GrNativeRect, fY));
- GR_STATIC_ASSERT(8 == offsetof(GrNativeRect, fWidth));
- GR_STATIC_ASSERT(12 == offsetof(GrNativeRect, fHeight));
- GR_STATIC_ASSERT(16 == sizeof(GrNativeRect)); // For an array of GrNativeRect.
+ static_assert(0 == offsetof(GrNativeRect, fX));
+ static_assert(4 == offsetof(GrNativeRect, fY));
+ static_assert(8 == offsetof(GrNativeRect, fWidth));
+ static_assert(12 == offsetof(GrNativeRect, fHeight));
+ static_assert(16 == sizeof(GrNativeRect)); // For an array of GrNativeRect.
}
int* asInts() { return &fX; }
diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp
index e21d1bc..71efe38 100644
--- a/src/gpu/GrPathRendererChain.cpp
+++ b/src/gpu/GrPathRendererChain.cpp
@@ -78,10 +78,10 @@
const GrPathRenderer::CanDrawPathArgs& args,
DrawType drawType,
GrPathRenderer::StencilSupport* stencilSupport) {
- GR_STATIC_ASSERT(GrPathRenderer::kNoSupport_StencilSupport <
- GrPathRenderer::kStencilOnly_StencilSupport);
- GR_STATIC_ASSERT(GrPathRenderer::kStencilOnly_StencilSupport <
- GrPathRenderer::kNoRestriction_StencilSupport);
+ static_assert(GrPathRenderer::kNoSupport_StencilSupport <
+ GrPathRenderer::kStencilOnly_StencilSupport);
+ static_assert(GrPathRenderer::kStencilOnly_StencilSupport <
+ GrPathRenderer::kNoRestriction_StencilSupport);
GrPathRenderer::StencilSupport minStencilSupport;
if (DrawType::kStencil == drawType) {
minStencilSupport = GrPathRenderer::kStencilOnly_StencilSupport;
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index f653542..418b73e 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -101,8 +101,8 @@
static const uint32_t kBlendWriteShift = 1;
static const uint32_t kBlendCoeffShift = 5;
- GR_STATIC_ASSERT(kLast_GrBlendCoeff < (1 << kBlendCoeffShift));
- GR_STATIC_ASSERT(kFirstAdvancedGrBlendEquation - 1 < 4);
+ static_assert(kLast_GrBlendCoeff < (1 << kBlendCoeffShift));
+ static_assert(kFirstAdvancedGrBlendEquation - 1 < 4);
uint32_t blendKey = blendInfo.fWriteColor;
blendKey |= (blendInfo.fSrcBlend << kBlendWriteShift);
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index e155c67..b1e7c63 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -121,7 +121,7 @@
friend class GrProcessorSet;
};
- GR_STATIC_ASSERT(sizeof(Analysis) <= sizeof(uint32_t));
+ static_assert(sizeof(Analysis) <= sizeof(uint32_t));
/**
* This analyzes the processors given an op's input color and coverage as well as a clip. The
diff --git a/src/gpu/GrProgramDesc.cpp b/src/gpu/GrProgramDesc.cpp
index 38161c6..0139d04 100644
--- a/src/gpu/GrProgramDesc.cpp
+++ b/src/gpu/GrProgramDesc.cpp
@@ -48,7 +48,7 @@
const GrCaps& caps) {
int samplerTypeKey = texture_type_key(textureType);
- GR_STATIC_ASSERT(2 == sizeof(swizzle.asKey()));
+ static_assert(2 == sizeof(swizzle.asKey()));
uint16_t swizzleKey = 0;
if (caps.shaderCaps()->textureSwizzleAppliedInShader()) {
swizzleKey = swizzle.asKey();
@@ -184,7 +184,7 @@
// bindings in use or other descriptor field settings) it should be set
// to a canonical value to avoid duplicate programs with different keys.
- GR_STATIC_ASSERT(0 == kProcessorKeysOffset % sizeof(uint32_t));
+ static_assert(0 == kProcessorKeysOffset % sizeof(uint32_t));
// Make room for everything up to the effect keys.
desc->key().reset();
desc->key().push_back_n(kProcessorKeysOffset);
diff --git a/src/gpu/GrProgramDesc.h b/src/gpu/GrProgramDesc.h
index c0cfaa8..07b0110 100644
--- a/src/gpu/GrProgramDesc.h
+++ b/src/gpu/GrProgramDesc.h
@@ -113,7 +113,7 @@
// portions added by the platform-specific backends.
uint32_t fInitialKeyLength : 27;
};
- GR_STATIC_ASSERT(sizeof(KeyHeader) == 8);
+ static_assert(sizeof(KeyHeader) == 8);
const KeyHeader& header() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index 3068b9b..31b502a 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -397,13 +397,13 @@
static const int kIndicesPerNonAAQuad = 6;
sk_sp<const GrGpuBuffer> GrResourceProvider::createNonAAQuadIndexBuffer() {
- GR_STATIC_ASSERT(kVertsPerNonAAQuad * kMaxNumNonAAQuads <= 65535); // indices fit in a uint16_t
+ static_assert(kVertsPerNonAAQuad * kMaxNumNonAAQuads <= 65535); // indices fit in a uint16_t
static const uint16_t kNonAAQuadIndexPattern[] = {
0, 1, 2, 2, 1, 3
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kNonAAQuadIndexPattern) == kIndicesPerNonAAQuad);
+ static_assert(SK_ARRAY_COUNT(kNonAAQuadIndexPattern) == kIndicesPerNonAAQuad);
return this->createPatternedIndexBuffer(kNonAAQuadIndexPattern, kIndicesPerNonAAQuad,
kMaxNumNonAAQuads, kVertsPerNonAAQuad, nullptr);
@@ -419,7 +419,7 @@
static const int kIndicesPerAAQuad = 30;
sk_sp<const GrGpuBuffer> GrResourceProvider::createAAQuadIndexBuffer() {
- GR_STATIC_ASSERT(kVertsPerAAQuad * kMaxNumAAQuads <= 65535); // indices fit in a uint16_t
+ static_assert(kVertsPerAAQuad * kMaxNumAAQuads <= 65535); // indices fit in a uint16_t
// clang-format off
static const uint16_t kAAQuadIndexPattern[] = {
@@ -431,7 +431,7 @@
};
// clang-format on
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kAAQuadIndexPattern) == kIndicesPerAAQuad);
+ static_assert(SK_ARRAY_COUNT(kAAQuadIndexPattern) == kIndicesPerAAQuad);
return this->createPatternedIndexBuffer(kAAQuadIndexPattern, kIndicesPerAAQuad,
kMaxNumAAQuads, kVertsPerAAQuad, nullptr);
diff --git a/src/gpu/GrShaderCaps.cpp b/src/gpu/GrShaderCaps.cpp
index 60ea381..6202db6 100644
--- a/src/gpu/GrShaderCaps.cpp
+++ b/src/gpu/GrShaderCaps.cpp
@@ -93,11 +93,11 @@
"General Enable",
"Specific Enables",
};
- GR_STATIC_ASSERT(0 == kNotSupported_AdvBlendEqInteraction);
- GR_STATIC_ASSERT(1 == kAutomatic_AdvBlendEqInteraction);
- GR_STATIC_ASSERT(2 == kGeneralEnable_AdvBlendEqInteraction);
- GR_STATIC_ASSERT(3 == kSpecificEnables_AdvBlendEqInteraction);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kAdvBlendEqInteractionStr) == kLast_AdvBlendEqInteraction + 1);
+ static_assert(0 == kNotSupported_AdvBlendEqInteraction);
+ static_assert(1 == kAutomatic_AdvBlendEqInteraction);
+ static_assert(2 == kGeneralEnable_AdvBlendEqInteraction);
+ static_assert(3 == kSpecificEnables_AdvBlendEqInteraction);
+ static_assert(SK_ARRAY_COUNT(kAdvBlendEqInteractionStr) == kLast_AdvBlendEqInteraction + 1);
writer->appendBool("FB Fetch Support", fFBFetchSupport);
writer->appendBool("Uses precision modifiers", fUsesPrecisionModifiers);
diff --git a/src/gpu/GrStencilSettings.cpp b/src/gpu/GrStencilSettings.cpp
index f39648c..41957ff 100644
--- a/src/gpu/GrStencilSettings.cpp
+++ b/src/gpu/GrStencilSettings.cpp
@@ -20,7 +20,7 @@
0x0000>()
);
-GR_STATIC_ASSERT(kAll_StencilFlags == (gUnused.fCWFlags[0] & gUnused.fCCWFlags[0]));
+static_assert(kAll_StencilFlags == (gUnused.fCWFlags[0] & gUnused.fCCWFlags[0]));
const GrUserStencilSettings& GrUserStencilSettings::kUnused = gUnused;
@@ -62,8 +62,8 @@
memcpy(&fCWFace, &that.fCWFace, sizeof(Face));
} else {
memcpy(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
- GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
+ static_assert(sizeof(Face) ==
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
}
@@ -82,23 +82,23 @@
return false;
} else {
return 0 == memcmp(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
- GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
+ static_assert(sizeof(Face) ==
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
// memcmp relies on GrStencilSettings::Face being tightly packed.
- GR_STATIC_ASSERT(0 == offsetof(Face, fRef));
- GR_STATIC_ASSERT(2 == sizeof(Face::fRef));
- GR_STATIC_ASSERT(2 == offsetof(Face, fTest));
- GR_STATIC_ASSERT(2 == sizeof(Face::fTest));
- GR_STATIC_ASSERT(4 == offsetof(Face, fTestMask));
- GR_STATIC_ASSERT(2 == sizeof(Face::fTestMask));
- GR_STATIC_ASSERT(6 == offsetof(Face, fPassOp));
- GR_STATIC_ASSERT(1 == sizeof(Face::fPassOp));
- GR_STATIC_ASSERT(7 == offsetof(Face, fFailOp));
- GR_STATIC_ASSERT(1 == sizeof(Face::fFailOp));
- GR_STATIC_ASSERT(8 == offsetof(Face, fWriteMask));
- GR_STATIC_ASSERT(2 == sizeof(Face::fWriteMask));
- GR_STATIC_ASSERT(10 == sizeof(Face));
+ static_assert(0 == offsetof(Face, fRef));
+ static_assert(2 == sizeof(Face::fRef));
+ static_assert(2 == offsetof(Face, fTest));
+ static_assert(2 == sizeof(Face::fTest));
+ static_assert(4 == offsetof(Face, fTestMask));
+ static_assert(2 == sizeof(Face::fTestMask));
+ static_assert(6 == offsetof(Face, fPassOp));
+ static_assert(1 == sizeof(Face::fPassOp));
+ static_assert(7 == offsetof(Face, fFailOp));
+ static_assert(1 == sizeof(Face::fFailOp));
+ static_assert(8 == offsetof(Face, fWriteMask));
+ static_assert(2 == sizeof(Face::fWriteMask));
+ static_assert(10 == sizeof(Face));
}
static constexpr GrStencilTest gUserStencilTestToRaw[kGrUserStencilTestCount] = {
@@ -119,18 +119,18 @@
GrStencilTest::kNotEqual
};
-GR_STATIC_ASSERT(0 == (int)GrUserStencilTest::kAlwaysIfInClip);
-GR_STATIC_ASSERT(1 == (int)GrUserStencilTest::kEqualIfInClip);
-GR_STATIC_ASSERT(2 == (int)GrUserStencilTest::kLessIfInClip);
-GR_STATIC_ASSERT(3 == (int)GrUserStencilTest::kLEqualIfInClip);
-GR_STATIC_ASSERT(4 == (int)GrUserStencilTest::kAlways);
-GR_STATIC_ASSERT(5 == (int)GrUserStencilTest::kNever);
-GR_STATIC_ASSERT(6 == (int)GrUserStencilTest::kGreater);
-GR_STATIC_ASSERT(7 == (int)GrUserStencilTest::kGEqual);
-GR_STATIC_ASSERT(8 == (int)GrUserStencilTest::kLess);
-GR_STATIC_ASSERT(9 == (int)GrUserStencilTest::kLEqual);
-GR_STATIC_ASSERT(10 == (int)GrUserStencilTest::kEqual);
-GR_STATIC_ASSERT(11 == (int)GrUserStencilTest::kNotEqual);
+static_assert(0 == (int)GrUserStencilTest::kAlwaysIfInClip);
+static_assert(1 == (int)GrUserStencilTest::kEqualIfInClip);
+static_assert(2 == (int)GrUserStencilTest::kLessIfInClip);
+static_assert(3 == (int)GrUserStencilTest::kLEqualIfInClip);
+static_assert(4 == (int)GrUserStencilTest::kAlways);
+static_assert(5 == (int)GrUserStencilTest::kNever);
+static_assert(6 == (int)GrUserStencilTest::kGreater);
+static_assert(7 == (int)GrUserStencilTest::kGEqual);
+static_assert(8 == (int)GrUserStencilTest::kLess);
+static_assert(9 == (int)GrUserStencilTest::kLEqual);
+static_assert(10 == (int)GrUserStencilTest::kEqual);
+static_assert(11 == (int)GrUserStencilTest::kNotEqual);
static constexpr GrStencilOp gUserStencilOpToRaw[kGrUserStencilOpCount] = {
GrStencilOp::kKeep,
@@ -154,19 +154,19 @@
GrStencilOp::kZero // kZeroClipAndUserBits.
};
-GR_STATIC_ASSERT(0 == (int)GrUserStencilOp::kKeep);
-GR_STATIC_ASSERT(1 == (int)GrUserStencilOp::kZero);
-GR_STATIC_ASSERT(2 == (int)GrUserStencilOp::kReplace);
-GR_STATIC_ASSERT(3 == (int)GrUserStencilOp::kInvert);
-GR_STATIC_ASSERT(4 == (int)GrUserStencilOp::kIncWrap);
-GR_STATIC_ASSERT(5 == (int)GrUserStencilOp::kDecWrap);
-GR_STATIC_ASSERT(6 == (int)GrUserStencilOp::kIncMaybeClamp);
-GR_STATIC_ASSERT(7 == (int)GrUserStencilOp::kDecMaybeClamp);
-GR_STATIC_ASSERT(8 == (int)GrUserStencilOp::kZeroClipBit);
-GR_STATIC_ASSERT(9 == (int)GrUserStencilOp::kSetClipBit);
-GR_STATIC_ASSERT(10 == (int)GrUserStencilOp::kInvertClipBit);
-GR_STATIC_ASSERT(11 == (int)GrUserStencilOp::kSetClipAndReplaceUserBits);
-GR_STATIC_ASSERT(12 == (int)GrUserStencilOp::kZeroClipAndUserBits);
+static_assert(0 == (int)GrUserStencilOp::kKeep);
+static_assert(1 == (int)GrUserStencilOp::kZero);
+static_assert(2 == (int)GrUserStencilOp::kReplace);
+static_assert(3 == (int)GrUserStencilOp::kInvert);
+static_assert(4 == (int)GrUserStencilOp::kIncWrap);
+static_assert(5 == (int)GrUserStencilOp::kDecWrap);
+static_assert(6 == (int)GrUserStencilOp::kIncMaybeClamp);
+static_assert(7 == (int)GrUserStencilOp::kDecMaybeClamp);
+static_assert(8 == (int)GrUserStencilOp::kZeroClipBit);
+static_assert(9 == (int)GrUserStencilOp::kSetClipBit);
+static_assert(10 == (int)GrUserStencilOp::kInvertClipBit);
+static_assert(11 == (int)GrUserStencilOp::kSetClipAndReplaceUserBits);
+static_assert(12 == (int)GrUserStencilOp::kZeroClipAndUserBits);
void GrStencilSettings::Face::reset(const GrUserStencilSettings::Face& user, bool hasStencilClip,
int numStencilBits) {
@@ -216,8 +216,8 @@
void GrStencilSettings::Face::setDisabled() {
memset(this, 0, sizeof(*this));
- GR_STATIC_ASSERT(0 == (int)GrStencilTest::kAlways);
- GR_STATIC_ASSERT(0 == (int)GrStencilOp::kKeep);
+ static_assert(0 == (int)GrStencilTest::kAlways);
+ static_assert(0 == (int)GrStencilOp::kKeep);
}
////////////////////////////////////////////////////////////////////////////////
@@ -367,12 +367,12 @@
}
};
-GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
-GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
-GR_STATIC_ASSERT(2 == SkRegion::kUnion_Op);
-GR_STATIC_ASSERT(3 == SkRegion::kXOR_Op);
-GR_STATIC_ASSERT(4 == SkRegion::kReverseDifference_Op);
-GR_STATIC_ASSERT(5 == SkRegion::kReplace_Op);
+static_assert(0 == SkRegion::kDifference_Op);
+static_assert(1 == SkRegion::kIntersect_Op);
+static_assert(2 == SkRegion::kUnion_Op);
+static_assert(3 == SkRegion::kXOR_Op);
+static_assert(4 == SkRegion::kReverseDifference_Op);
+static_assert(5 == SkRegion::kReplace_Op);
///////
// Direct to Stencil
@@ -432,12 +432,12 @@
{&gReplaceClip, nullptr} // kReplace_Op.
};
-GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
-GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
-GR_STATIC_ASSERT(2 == SkRegion::kUnion_Op);
-GR_STATIC_ASSERT(3 == SkRegion::kXOR_Op);
-GR_STATIC_ASSERT(4 == SkRegion::kReverseDifference_Op);
-GR_STATIC_ASSERT(5 == SkRegion::kReplace_Op);
+static_assert(0 == SkRegion::kDifference_Op);
+static_assert(1 == SkRegion::kIntersect_Op);
+static_assert(2 == SkRegion::kUnion_Op);
+static_assert(3 == SkRegion::kXOR_Op);
+static_assert(4 == SkRegion::kReverseDifference_Op);
+static_assert(5 == SkRegion::kReplace_Op);
GrUserStencilSettings const* const* GrStencilSettings::GetClipPasses(SkRegion::Op op,
bool canBeDirect,
@@ -476,31 +476,31 @@
}
if (!this->isTwoSided()) {
constexpr int kCount16 = sizeof(Face) / sizeof(uint16_t);
- GR_STATIC_ASSERT(0 == sizeof(Face) % sizeof(uint16_t));
+ static_assert(0 == sizeof(Face) % sizeof(uint16_t));
uint16_t* key = reinterpret_cast<uint16_t*>(b->add32n((kCount16 + 1) / 2));
memcpy(key, &fCWFace, sizeof(Face));
key[kCount16] = 0;
- GR_STATIC_ASSERT(1 == kCount16 % 2);
+ static_assert(1 == kCount16 % 2);
} else {
constexpr int kCount32 = (2 * sizeof(Face)) / sizeof(uint32_t);
- GR_STATIC_ASSERT(0 == (2 * sizeof(Face)) % sizeof(uint32_t));
+ static_assert(0 == (2 * sizeof(Face)) % sizeof(uint32_t));
uint32_t* key = b->add32n(kCount32);
memcpy(key, &fCWFace, 2 * sizeof(Face));
- GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
+ static_assert(sizeof(Face) ==
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
// We rely on GrStencilSettings::Face being tightly packed for the key to be reliable.
- GR_STATIC_ASSERT(0 == offsetof(Face, fRef));
- GR_STATIC_ASSERT(2 == sizeof(Face::fRef));
- GR_STATIC_ASSERT(2 == offsetof(Face, fTest));
- GR_STATIC_ASSERT(2 == sizeof(Face::fTest));
- GR_STATIC_ASSERT(4 == offsetof(Face, fTestMask));
- GR_STATIC_ASSERT(2 == sizeof(Face::fTestMask));
- GR_STATIC_ASSERT(6 == offsetof(Face, fPassOp));
- GR_STATIC_ASSERT(1 == sizeof(Face::fPassOp));
- GR_STATIC_ASSERT(7 == offsetof(Face, fFailOp));
- GR_STATIC_ASSERT(1 == sizeof(Face::fFailOp));
- GR_STATIC_ASSERT(8 == offsetof(Face, fWriteMask));
- GR_STATIC_ASSERT(2 == sizeof(Face::fWriteMask));
- GR_STATIC_ASSERT(10 == sizeof(Face));
+ static_assert(0 == offsetof(Face, fRef));
+ static_assert(2 == sizeof(Face::fRef));
+ static_assert(2 == offsetof(Face, fTest));
+ static_assert(2 == sizeof(Face::fTest));
+ static_assert(4 == offsetof(Face, fTestMask));
+ static_assert(2 == sizeof(Face::fTestMask));
+ static_assert(6 == offsetof(Face, fPassOp));
+ static_assert(1 == sizeof(Face::fPassOp));
+ static_assert(7 == offsetof(Face, fFailOp));
+ static_assert(1 == sizeof(Face::fFailOp));
+ static_assert(8 == offsetof(Face, fWriteMask));
+ static_assert(2 == sizeof(Face::fWriteMask));
+ static_assert(10 == sizeof(Face));
}
diff --git a/src/gpu/GrStyle.cpp b/src/gpu/GrStyle.cpp
index 305b5b3..caf361b 100644
--- a/src/gpu/GrStyle.cpp
+++ b/src/gpu/GrStyle.cpp
@@ -9,7 +9,7 @@
#include "src/utils/SkDashPathPriv.h"
int GrStyle::KeySize(const GrStyle &style, Apply apply, uint32_t flags) {
- GR_STATIC_ASSERT(sizeof(uint32_t) == sizeof(SkScalar));
+ static_assert(sizeof(uint32_t) == sizeof(SkScalar));
int size = 0;
if (style.isDashed()) {
// One scalar for scale, one for dash phase, and one for each dash value.
@@ -34,7 +34,7 @@
uint32_t flags) {
SkASSERT(key);
SkASSERT(KeySize(style, apply) >= 0);
- GR_STATIC_ASSERT(sizeof(uint32_t) == sizeof(SkScalar));
+ static_assert(sizeof(uint32_t) == sizeof(SkScalar));
int i = 0;
// The scale can influence both the path effect and stroking. We want to preserve the
@@ -44,7 +44,7 @@
// from SkStrokeRec output by the the path effect (and no additional path effect).
// Since the scale can affect both parts of 2 we write it into the key twice.
if (style.isDashed()) {
- GR_STATIC_ASSERT(sizeof(style.dashPhase()) == sizeof(uint32_t));
+ static_assert(sizeof(style.dashPhase()) == sizeof(uint32_t));
SkScalar phase = style.dashPhase();
memcpy(&key[i++], &scale, sizeof(SkScalar));
memcpy(&key[i++], &phase, sizeof(SkScalar));
@@ -70,9 +70,9 @@
kJoinShift = kStyleBits,
kCapShift = kJoinShift + kJoinBits,
};
- GR_STATIC_ASSERT(SkStrokeRec::kStyleCount <= (1 << kStyleBits));
- GR_STATIC_ASSERT(SkPaint::kJoinCount <= (1 << kJoinBits));
- GR_STATIC_ASSERT(SkPaint::kCapCount <= (1 << kCapBits));
+ static_assert(SkStrokeRec::kStyleCount <= (1 << kStyleBits));
+ static_assert(SkPaint::kJoinCount <= (1 << kJoinBits));
+ static_assert(SkPaint::kCapCount <= (1 << kCapBits));
// The cap type only matters for unclosed shapes. However, a path effect could unclose
// the shape before it is stroked.
SkPaint::Cap cap = SkPaint::kDefault_Cap;
diff --git a/src/gpu/GrSwizzle.cpp b/src/gpu/GrSwizzle.cpp
index b52d207..3bef983 100644
--- a/src/gpu/GrSwizzle.cpp
+++ b/src/gpu/GrSwizzle.cpp
@@ -24,7 +24,7 @@
pipeline->append(SkRasterPipeline::force_opaque);
return;
default: {
- GR_STATIC_ASSERT(sizeof(uintptr_t) >= 4 * sizeof(char));
+ static_assert(sizeof(uintptr_t) >= 4 * sizeof(char));
// Rather than allocate the 4 control bytes on the heap somewhere, just jam them right
// into a uintptr_t context.
uintptr_t ctx;
diff --git a/src/gpu/GrTRecorder.h b/src/gpu/GrTRecorder.h
index 1e87ec8..8e7edf9 100644
--- a/src/gpu/GrTRecorder.h
+++ b/src/gpu/GrTRecorder.h
@@ -110,7 +110,7 @@
static constexpr size_t kAllocAlign = kTAlign > kHeaderAlign ? kTAlign : kHeaderAlign;
static constexpr size_t kTItemOffset = GrSizeAlignUp(sizeof(Header), kAllocAlign);
// We're assuming if we back up from kItemOffset by sizeof(Header) we will still be aligned.
- GR_STATIC_ASSERT(sizeof(Header) % alignof(Header) == 0);
+ static_assert(sizeof(Header) % alignof(Header) == 0);
const size_t totalSize = kTItemOffset + sizeof(TItem) + extraDataSize;
auto alloc = reinterpret_cast<char*>(fArena.makeBytesAlignedTo(totalSize, kAllocAlign));
Header* header = new (alloc + kTItemOffset - sizeof(Header)) Header();
@@ -134,7 +134,7 @@
for (auto& i : *this) {
i.~TBase();
}
- GR_STATIC_ASSERT(std::is_trivially_destructible<Header>::value);
+ static_assert(std::is_trivially_destructible<Header>::value);
fHead = fTail = nullptr;
fArena.reset();
}
diff --git a/src/gpu/GrUserStencilSettings.h b/src/gpu/GrUserStencilSettings.h
index 95e97bc..d492120 100644
--- a/src/gpu/GrUserStencilSettings.h
+++ b/src/gpu/GrUserStencilSettings.h
@@ -213,11 +213,11 @@
template<GrUserStencilTest Test, GrUserStencilOp PassOp, GrUserStencilOp FailOp>
struct GrUserStencilSettings::Attrs {
// Ensure an op that only modifies user bits isn't paired with one that modifies clip bits.
- GR_STATIC_ASSERT(GrUserStencilOp::kKeep == PassOp || GrUserStencilOp::kKeep == FailOp ||
- (PassOp <= kLastUserOnlyStencilOp) == (FailOp <= kLastUserOnlyStencilOp));
+ static_assert(GrUserStencilOp::kKeep == PassOp || GrUserStencilOp::kKeep == FailOp ||
+ (PassOp <= kLastUserOnlyStencilOp) == (FailOp <= kLastUserOnlyStencilOp));
// Ensure an op that only modifies clip bits isn't paired with one that modifies clip and user.
- GR_STATIC_ASSERT(GrUserStencilOp::kKeep == PassOp || GrUserStencilOp::kKeep == FailOp ||
- (PassOp <= kLastClipOnlyStencilOp) == (FailOp <= kLastClipOnlyStencilOp));
+ static_assert(GrUserStencilOp::kKeep == PassOp || GrUserStencilOp::kKeep == FailOp ||
+ (PassOp <= kLastClipOnlyStencilOp) == (FailOp <= kLastClipOnlyStencilOp));
constexpr static bool TestAlwaysPasses(bool hasStencilClip) {
return (!hasStencilClip && GrUserStencilTest::kAlwaysIfInClip == Test) ||
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index 983d272..6eae933 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -29,7 +29,7 @@
kBlend_GrXferBarrierType, //<! Required by certain blend extensions.
};
/** Should be able to treat kNone as false in boolean expressions */
-GR_STATIC_ASSERT(SkToBool(kNone_GrXferBarrierType) == false);
+static_assert(SkToBool(kNone_GrXferBarrierType) == false);
/**
* GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h
index 79a6882..6996f49 100644
--- a/src/gpu/SkGr.h
+++ b/src/gpu/SkGr.h
@@ -163,17 +163,17 @@
//////////////////////////////////////////////////////////////////////////////
-GR_STATIC_ASSERT((int)kZero_GrBlendCoeff == (int)SkBlendModeCoeff::kZero);
-GR_STATIC_ASSERT((int)kOne_GrBlendCoeff == (int)SkBlendModeCoeff::kOne);
-GR_STATIC_ASSERT((int)kSC_GrBlendCoeff == (int)SkBlendModeCoeff::kSC);
-GR_STATIC_ASSERT((int)kISC_GrBlendCoeff == (int)SkBlendModeCoeff::kISC);
-GR_STATIC_ASSERT((int)kDC_GrBlendCoeff == (int)SkBlendModeCoeff::kDC);
-GR_STATIC_ASSERT((int)kIDC_GrBlendCoeff == (int)SkBlendModeCoeff::kIDC);
-GR_STATIC_ASSERT((int)kSA_GrBlendCoeff == (int)SkBlendModeCoeff::kSA);
-GR_STATIC_ASSERT((int)kISA_GrBlendCoeff == (int)SkBlendModeCoeff::kISA);
-GR_STATIC_ASSERT((int)kDA_GrBlendCoeff == (int)SkBlendModeCoeff::kDA);
-GR_STATIC_ASSERT((int)kIDA_GrBlendCoeff == (int)SkBlendModeCoeff::kIDA);
-//GR_STATIC_ASSERT(SkXfermode::kCoeffCount == 10);
+static_assert((int)kZero_GrBlendCoeff == (int)SkBlendModeCoeff::kZero);
+static_assert((int)kOne_GrBlendCoeff == (int)SkBlendModeCoeff::kOne);
+static_assert((int)kSC_GrBlendCoeff == (int)SkBlendModeCoeff::kSC);
+static_assert((int)kISC_GrBlendCoeff == (int)SkBlendModeCoeff::kISC);
+static_assert((int)kDC_GrBlendCoeff == (int)SkBlendModeCoeff::kDC);
+static_assert((int)kIDC_GrBlendCoeff == (int)SkBlendModeCoeff::kIDC);
+static_assert((int)kSA_GrBlendCoeff == (int)SkBlendModeCoeff::kSA);
+static_assert((int)kISA_GrBlendCoeff == (int)SkBlendModeCoeff::kISA);
+static_assert((int)kDA_GrBlendCoeff == (int)SkBlendModeCoeff::kDA);
+static_assert((int)kIDA_GrBlendCoeff == (int)SkBlendModeCoeff::kIDA);
+// static_assert(SkXfermode::kCoeffCount == 10);
////////////////////////////////////////////////////////////////////////////////
// Texture management
diff --git a/src/gpu/ccpr/GrCCPathCache.cpp b/src/gpu/ccpr/GrCCPathCache.cpp
index 347ce3d..8e01456 100644
--- a/src/gpu/ccpr/GrCCPathCache.cpp
+++ b/src/gpu/ccpr/GrCCPathCache.cpp
@@ -147,7 +147,7 @@
memcpy(&out[kStrokeWidthIdx], &width, sizeof(float));
memcpy(&out[kStrokeMiterIdx], &miterLimit, sizeof(float));
out[kStrokeCapJoinIdx] = (stroke.getCap() << 16) | stroke.getJoin();
- GR_STATIC_ASSERT(sizeof(out[kStrokeWidthIdx]) == sizeof(float));
+ static_assert(sizeof(out[kStrokeWidthIdx]) == sizeof(float));
}
// Shape unstyled key.
diff --git a/src/gpu/ccpr/GrCCPathProcessor.h b/src/gpu/ccpr/GrCCPathProcessor.h
index 7fcb256..3f13647 100644
--- a/src/gpu/ccpr/GrCCPathProcessor.h
+++ b/src/gpu/ccpr/GrCCPathProcessor.h
@@ -44,7 +44,7 @@
void set(const GrCCPathCacheEntry&, const SkIVector& shift, uint64_t, GrFillRule);
};
- GR_STATIC_ASSERT(4 * 12 == sizeof(Instance));
+ static_assert(4 * 12 == sizeof(Instance));
static sk_sp<const GrGpuBuffer> FindVertexBuffer(GrOnFlushResourceProvider*);
static sk_sp<const GrGpuBuffer> FindIndexBuffer(GrOnFlushResourceProvider*);
diff --git a/src/gpu/ccpr/GrGSCoverageProcessor.cpp b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
index 09941fd..2a9b917 100644
--- a/src/gpu/ccpr/GrGSCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
@@ -415,15 +415,15 @@
if (4 == this->numInputPoints() || this->hasInputWeight()) {
fInputXOrYValues =
{"x_or_y_values", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
- GR_STATIC_ASSERT(sizeof(QuadPointInstance) ==
- 2 * GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
- GR_STATIC_ASSERT(offsetof(QuadPointInstance, fY) ==
- GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
+ static_assert(sizeof(QuadPointInstance) ==
+ 2 * GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
+ static_assert(offsetof(QuadPointInstance, fY) ==
+ GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
} else {
fInputXOrYValues =
{"x_or_y_values", kFloat3_GrVertexAttribType, kFloat3_GrSLType};
- GR_STATIC_ASSERT(sizeof(TriPointInstance) ==
- 2 * GrVertexAttribTypeSize(kFloat3_GrVertexAttribType));
+ static_assert(sizeof(TriPointInstance) ==
+ 2 * GrVertexAttribTypeSize(kFloat3_GrVertexAttribType));
}
this->setVertexAttributes(&fInputXOrYValues, 1);
diff --git a/src/gpu/ccpr/GrVSCoverageProcessor.cpp b/src/gpu/ccpr/GrVSCoverageProcessor.cpp
index 05819f3..849f8ba 100644
--- a/src/gpu/ccpr/GrVSCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrVSCoverageProcessor.cpp
@@ -504,16 +504,16 @@
GrVertexAttribType xyAttribType;
GrSLType xySLType;
if (4 == this->numInputPoints() || this->hasInputWeight()) {
- GR_STATIC_ASSERT(offsetof(QuadPointInstance, fX) == 0);
- GR_STATIC_ASSERT(sizeof(QuadPointInstance::fX) ==
- GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
- GR_STATIC_ASSERT(sizeof(QuadPointInstance::fY) ==
- GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
+ static_assert(offsetof(QuadPointInstance, fX) == 0);
+ static_assert(sizeof(QuadPointInstance::fX) ==
+ GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
+ static_assert(sizeof(QuadPointInstance::fY) ==
+ GrVertexAttribTypeSize(kFloat4_GrVertexAttribType));
xyAttribType = kFloat4_GrVertexAttribType;
xySLType = kFloat4_GrSLType;
} else {
- GR_STATIC_ASSERT(sizeof(TriPointInstance) ==
- 2 * GrVertexAttribTypeSize(kFloat3_GrVertexAttribType));
+ static_assert(sizeof(TriPointInstance) ==
+ 2 * GrVertexAttribTypeSize(kFloat3_GrVertexAttribType));
xyAttribType = kFloat3_GrVertexAttribType;
xySLType = kFloat3_GrSLType;
}
diff --git a/src/gpu/dawn/GrDawnCaps.cpp b/src/gpu/dawn/GrDawnCaps.cpp
index 52ff461..65ccb00 100644
--- a/src/gpu/dawn/GrDawnCaps.cpp
+++ b/src/gpu/dawn/GrDawnCaps.cpp
@@ -221,8 +221,8 @@
static const uint32_t kBlendWriteShift = 1;
static const uint32_t kBlendCoeffShift = 5;
- GR_STATIC_ASSERT(kLast_GrBlendCoeff < (1 << kBlendCoeffShift));
- GR_STATIC_ASSERT(kFirstAdvancedGrBlendEquation - 1 < 4);
+ static_assert(kLast_GrBlendCoeff < (1 << kBlendCoeffShift));
+ static_assert(kFirstAdvancedGrBlendEquation - 1 < 4);
uint32_t key = blendInfo.fWriteColor;
key |= (blendInfo.fSrcBlend << kBlendWriteShift);
diff --git a/src/gpu/dawn/GrDawnProgramDataManager.cpp b/src/gpu/dawn/GrDawnProgramDataManager.cpp
index c740edc..bfb7679 100644
--- a/src/gpu/dawn/GrDawnProgramDataManager.cpp
+++ b/src/gpu/dawn/GrDawnProgramDataManager.cpp
@@ -215,7 +215,7 @@
template<int N> struct set_uniform_matrix {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
for (int i = 0; i < count; ++i) {
const float* matrix = &matrices[N * N * i];
@@ -229,7 +229,7 @@
template<> struct set_uniform_matrix<4> {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
memcpy(buffer, matrices, count * 16 * sizeof(float));
}
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index 64911cc..4872a9c 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -81,7 +81,7 @@
void GrGLConvexPolyEffect::GenKey(const GrProcessor& processor, const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
const GrConvexPolyEffect& cpe = processor.cast<GrConvexPolyEffect>();
- GR_STATIC_ASSERT(kGrClipEdgeTypeCnt <= 8);
+ static_assert(kGrClipEdgeTypeCnt <= 8);
uint32_t key = (cpe.getEdgeCount() << 3) | (int) cpe.getEdgeType();
b->add32(key);
}
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 4af5345..f7ecbf1 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -32,23 +32,23 @@
static constexpr GrBlendEquation hw_blend_equation(SkBlendMode mode) {
// In C++14 this could be a constexpr int variable.
#define EQ_OFFSET (kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay)
- GR_STATIC_ASSERT(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + EQ_OFFSET);
- GR_STATIC_ASSERT(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + EQ_OFFSET);
- GR_STATIC_ASSERT(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + EQ_OFFSET);
- GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + EQ_OFFSET);
- GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + EQ_OFFSET);
- GR_STATIC_ASSERT(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + EQ_OFFSET);
- GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + EQ_OFFSET);
- GR_STATIC_ASSERT(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + EQ_OFFSET);
- GR_STATIC_ASSERT(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + EQ_OFFSET);
- GR_STATIC_ASSERT(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + EQ_OFFSET);
- GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + EQ_OFFSET);
- GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + EQ_OFFSET);
- GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + EQ_OFFSET);
- GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + EQ_OFFSET);
+ static_assert(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + EQ_OFFSET);
+ static_assert(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + EQ_OFFSET);
+ static_assert(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + EQ_OFFSET);
+ static_assert(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + EQ_OFFSET);
+ static_assert(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + EQ_OFFSET);
+ static_assert(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + EQ_OFFSET);
+ static_assert(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + EQ_OFFSET);
+ static_assert(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + EQ_OFFSET);
+ static_assert(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + EQ_OFFSET);
+ static_assert(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + EQ_OFFSET);
+ static_assert(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + EQ_OFFSET);
+ static_assert(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + EQ_OFFSET);
+ static_assert(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + EQ_OFFSET);
+ static_assert(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + EQ_OFFSET);
// There's an illegal GrBlendEquation that corresponds to no SkBlendMode, hence the extra +1.
- GR_STATIC_ASSERT(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + 1 + EQ_OFFSET);
+ static_assert(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + 1 + EQ_OFFSET);
return static_cast<GrBlendEquation>((int)mode + EQ_OFFSET);
#undef EQ_OFFSET
@@ -126,7 +126,7 @@
if (xp.hasHWBlendEquation()) {
SkASSERT(caps.advBlendEqInteraction() > 0); // 0 will mean !xp.hasHWBlendEquation().
key |= caps.advBlendEqInteraction();
- GR_STATIC_ASSERT(GrShaderCaps::kLast_AdvBlendEqInteraction < 4);
+ static_assert(GrShaderCaps::kLast_AdvBlendEqInteraction < 4);
}
if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) {
key |= (int)xp.mode() << 3;
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index 47d92db..4cfd623 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -158,13 +158,13 @@
uint32_t fData;
};
- GR_STATIC_ASSERT(kLast_OutputType < (1 << 3));
- GR_STATIC_ASSERT(kLast_GrBlendEquation < (1 << 5));
- GR_STATIC_ASSERT(kLast_GrBlendCoeff < (1 << 5));
- GR_STATIC_ASSERT(kLast_Property < (1 << 6));
+ static_assert(kLast_OutputType < (1 << 3));
+ static_assert(kLast_GrBlendEquation < (1 << 5));
+ static_assert(kLast_GrBlendCoeff < (1 << 5));
+ static_assert(kLast_Property < (1 << 6));
};
-GR_STATIC_ASSERT(4 == sizeof(BlendFormula));
+static_assert(4 == sizeof(BlendFormula));
GR_MAKE_BITFIELD_OPS(BlendFormula::Properties);
@@ -470,7 +470,7 @@
const PorterDuffXferProcessor& xp = processor.cast<PorterDuffXferProcessor>();
b->add32(xp.getBlendFormula().primaryOutput() |
(xp.getBlendFormula().secondaryOutput() << 3));
- GR_STATIC_ASSERT(BlendFormula::kLast_OutputType < 8);
+ static_assert(BlendFormula::kLast_OutputType < 8);
}
private:
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 9c9dc31..335f67e 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -285,7 +285,7 @@
void GLCircularRRectEffect::GenKey(const GrProcessor& processor, const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
- GR_STATIC_ASSERT(kGrClipEdgeTypeCnt <= 8);
+ static_assert(kGrClipEdgeTypeCnt <= 8);
b->add32((crre.getCircularCornerFlags() << 3) | (int) crre.getEdgeType());
}
@@ -592,7 +592,7 @@
void GLEllipticalRRectEffect::GenKey(const GrProcessor& effect, const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
- GR_STATIC_ASSERT((int) GrClipEdgeType::kLast < (1 << 3));
+ static_assert((int)GrClipEdgeType::kLast < (1 << 3));
b->add32(erre.getRRect().getType() | (int) erre.getEdgeType() << 3);
}
diff --git a/src/gpu/effects/GrTextureDomain.h b/src/gpu/effects/GrTextureDomain.h
index 073a15b..68f07fc 100644
--- a/src/gpu/effects/GrTextureDomain.h
+++ b/src/gpu/effects/GrTextureDomain.h
@@ -192,7 +192,7 @@
* computed key. The returned will be limited to the lower kDomainKeyBits bits.
*/
static uint32_t DomainKey(const GrTextureDomain& domain) {
- GR_STATIC_ASSERT(kModeCount <= (1 << kModeBits));
+ static_assert(kModeCount <= (1 << kModeBits));
return domain.modeX() | (domain.modeY() << kModeBits);
}
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index d21b498..0eae5e4 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -387,7 +387,7 @@
}
void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
- GR_STATIC_ASSERT(((int)SkBlendMode::kLastMode & UINT16_MAX) == (int)SkBlendMode::kLastMode);
+ static_assert(((int)SkBlendMode::kLastMode & UINT16_MAX) == (int)SkBlendMode::kLastMode);
b->add32((int)fMode | (fChild << 16));
}
diff --git a/src/gpu/geometry/GrPathUtils.cpp b/src/gpu/geometry/GrPathUtils.cpp
index 0b3dd23..4d34d08 100644
--- a/src/gpu/geometry/GrPathUtils.cpp
+++ b/src/gpu/geometry/GrPathUtils.cpp
@@ -637,7 +637,7 @@
ExcludedTerm GrPathUtils::calcCubicInverseTransposePowerBasisMatrix(const SkPoint p[4],
SkMatrix* out) {
- GR_STATIC_ASSERT(SK_SCALAR_IS_FLOAT);
+ static_assert(SK_SCALAR_IS_FLOAT);
// First convert the bezier coordinates p[0..3] to power basis coefficients X,Y(,W=[0 0 0 1]).
// M3 is the matrix that does this conversion. The homogeneous equation for the cubic becomes:
diff --git a/src/gpu/geometry/GrShape.cpp b/src/gpu/geometry/GrShape.cpp
index a510a19..8c29746 100644
--- a/src/gpu/geometry/GrShape.cpp
+++ b/src/gpu/geometry/GrShape.cpp
@@ -185,8 +185,8 @@
const int pointCnt = path.countPoints();
const int conicWeightCnt = SkPathPriv::ConicWeightCnt(path);
- GR_STATIC_ASSERT(sizeof(SkPoint) == 2 * sizeof(uint32_t));
- GR_STATIC_ASSERT(sizeof(SkScalar) == sizeof(uint32_t));
+ static_assert(sizeof(SkPoint) == 2 * sizeof(uint32_t));
+ static_assert(sizeof(SkScalar) == sizeof(uint32_t));
// 2 is for the verb cnt and a fill type. Each verb is a byte but we'll pad the verb data out to
// a uint32_t length.
return 2 + (SkAlign4(verbCnt) >> 2) + 2 * pointCnt + conicWeightCnt;
@@ -211,10 +211,10 @@
key += verbKeySize >> 2;
memcpy(key, SkPathPriv::PointData(path), sizeof(SkPoint) * pointCnt);
- GR_STATIC_ASSERT(sizeof(SkPoint) == 2 * sizeof(uint32_t));
+ static_assert(sizeof(SkPoint) == 2 * sizeof(uint32_t));
key += 2 * pointCnt;
sk_careful_memcpy(key, SkPathPriv::ConicWeightData(path), sizeof(SkScalar) * conicWeightCnt);
- GR_STATIC_ASSERT(sizeof(SkScalar) == sizeof(uint32_t));
+ static_assert(sizeof(SkScalar) == sizeof(uint32_t));
SkDEBUGCODE(key += conicWeightCnt);
SkASSERT(key - origKey == path_key_from_data_size(path));
}
@@ -230,15 +230,15 @@
return 1;
case Type::kRRect:
SkASSERT(!fInheritedKey.count());
- GR_STATIC_ASSERT(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
+ static_assert(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
// + 1 for the direction, start index, and inverseness.
return SkRRect::kSizeInMemory / sizeof(uint32_t) + 1;
case Type::kArc:
SkASSERT(!fInheritedKey.count());
- GR_STATIC_ASSERT(0 == sizeof(fArcData) % sizeof(uint32_t));
+ static_assert(0 == sizeof(fArcData) % sizeof(uint32_t));
return sizeof(fArcData) / sizeof(uint32_t);
case Type::kLine:
- GR_STATIC_ASSERT(2 * sizeof(uint32_t) == sizeof(SkPoint));
+ static_assert(2 * sizeof(uint32_t) == sizeof(SkPoint));
// 4 for the end points and 1 for the inverseness
return 5;
case Type::kPath: {
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 06db07e..c24c8a7 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -1105,22 +1105,22 @@
"IMG MS To Texture",
"EXT MS To Texture",
};
- GR_STATIC_ASSERT(0 == kNone_MSFBOType);
- GR_STATIC_ASSERT(1 == kStandard_MSFBOType);
- GR_STATIC_ASSERT(2 == kES_Apple_MSFBOType);
- GR_STATIC_ASSERT(3 == kES_IMG_MsToTexture_MSFBOType);
- GR_STATIC_ASSERT(4 == kES_EXT_MsToTexture_MSFBOType);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1);
+ static_assert(0 == kNone_MSFBOType);
+ static_assert(1 == kStandard_MSFBOType);
+ static_assert(2 == kES_Apple_MSFBOType);
+ static_assert(3 == kES_IMG_MsToTexture_MSFBOType);
+ static_assert(4 == kES_EXT_MsToTexture_MSFBOType);
+ static_assert(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1);
static const char* kInvalidateFBTypeStr[] = {
"None",
"Discard",
"Invalidate",
};
- GR_STATIC_ASSERT(0 == kNone_InvalidateFBType);
- GR_STATIC_ASSERT(1 == kDiscard_InvalidateFBType);
- GR_STATIC_ASSERT(2 == kInvalidate_InvalidateFBType);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1);
+ static_assert(0 == kNone_InvalidateFBType);
+ static_assert(1 == kDiscard_InvalidateFBType);
+ static_assert(2 == kInvalidate_InvalidateFBType);
+ static_assert(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1);
static const char* kMapBufferTypeStr[] = {
"None",
@@ -1128,11 +1128,11 @@
"MapBufferRange",
"Chromium",
};
- GR_STATIC_ASSERT(0 == kNone_MapBufferType);
- GR_STATIC_ASSERT(1 == kMapBuffer_MapBufferType);
- GR_STATIC_ASSERT(2 == kMapBufferRange_MapBufferType);
- GR_STATIC_ASSERT(3 == kChromium_MapBufferType);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMapBufferTypeStr) == kLast_MapBufferType + 1);
+ static_assert(0 == kNone_MapBufferType);
+ static_assert(1 == kMapBuffer_MapBufferType);
+ static_assert(2 == kMapBufferRange_MapBufferType);
+ static_assert(3 == kChromium_MapBufferType);
+ static_assert(SK_ARRAY_COUNT(kMapBufferTypeStr) == kLast_MapBufferType + 1);
writer->appendBool("Core Profile", fIsCoreProfile);
writer->appendString("MSAA Type", kMSFBOExtStr[fMSFBOType]);
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index d3fa6e1..90f8606 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -85,25 +85,25 @@
// Illegal... needs to map to something.
GR_GL_FUNC_ADD,
};
-GR_STATIC_ASSERT(0 == kAdd_GrBlendEquation);
-GR_STATIC_ASSERT(1 == kSubtract_GrBlendEquation);
-GR_STATIC_ASSERT(2 == kReverseSubtract_GrBlendEquation);
-GR_STATIC_ASSERT(3 == kScreen_GrBlendEquation);
-GR_STATIC_ASSERT(4 == kOverlay_GrBlendEquation);
-GR_STATIC_ASSERT(5 == kDarken_GrBlendEquation);
-GR_STATIC_ASSERT(6 == kLighten_GrBlendEquation);
-GR_STATIC_ASSERT(7 == kColorDodge_GrBlendEquation);
-GR_STATIC_ASSERT(8 == kColorBurn_GrBlendEquation);
-GR_STATIC_ASSERT(9 == kHardLight_GrBlendEquation);
-GR_STATIC_ASSERT(10 == kSoftLight_GrBlendEquation);
-GR_STATIC_ASSERT(11 == kDifference_GrBlendEquation);
-GR_STATIC_ASSERT(12 == kExclusion_GrBlendEquation);
-GR_STATIC_ASSERT(13 == kMultiply_GrBlendEquation);
-GR_STATIC_ASSERT(14 == kHSLHue_GrBlendEquation);
-GR_STATIC_ASSERT(15 == kHSLSaturation_GrBlendEquation);
-GR_STATIC_ASSERT(16 == kHSLColor_GrBlendEquation);
-GR_STATIC_ASSERT(17 == kHSLLuminosity_GrBlendEquation);
-GR_STATIC_ASSERT(SK_ARRAY_COUNT(gXfermodeEquation2Blend) == kGrBlendEquationCnt);
+static_assert(0 == kAdd_GrBlendEquation);
+static_assert(1 == kSubtract_GrBlendEquation);
+static_assert(2 == kReverseSubtract_GrBlendEquation);
+static_assert(3 == kScreen_GrBlendEquation);
+static_assert(4 == kOverlay_GrBlendEquation);
+static_assert(5 == kDarken_GrBlendEquation);
+static_assert(6 == kLighten_GrBlendEquation);
+static_assert(7 == kColorDodge_GrBlendEquation);
+static_assert(8 == kColorBurn_GrBlendEquation);
+static_assert(9 == kHardLight_GrBlendEquation);
+static_assert(10 == kSoftLight_GrBlendEquation);
+static_assert(11 == kDifference_GrBlendEquation);
+static_assert(12 == kExclusion_GrBlendEquation);
+static_assert(13 == kMultiply_GrBlendEquation);
+static_assert(14 == kHSLHue_GrBlendEquation);
+static_assert(15 == kHSLSaturation_GrBlendEquation);
+static_assert(16 == kHSLColor_GrBlendEquation);
+static_assert(17 == kHSLLuminosity_GrBlendEquation);
+static_assert(SK_ARRAY_COUNT(gXfermodeEquation2Blend) == kGrBlendEquationCnt);
static const GrGLenum gXfermodeCoeff2Blend[] = {
GR_GL_ZERO,
@@ -158,30 +158,30 @@
false,
};
return gCoeffReferencesBlendConst[coeff];
- GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
+ static_assert(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
- GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
- GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
- GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
- GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
- GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
- GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
- GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
- GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
- GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
- GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
- GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
- GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
- GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
- GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
+ static_assert(0 == kZero_GrBlendCoeff);
+ static_assert(1 == kOne_GrBlendCoeff);
+ static_assert(2 == kSC_GrBlendCoeff);
+ static_assert(3 == kISC_GrBlendCoeff);
+ static_assert(4 == kDC_GrBlendCoeff);
+ static_assert(5 == kIDC_GrBlendCoeff);
+ static_assert(6 == kSA_GrBlendCoeff);
+ static_assert(7 == kISA_GrBlendCoeff);
+ static_assert(8 == kDA_GrBlendCoeff);
+ static_assert(9 == kIDA_GrBlendCoeff);
+ static_assert(10 == kConstC_GrBlendCoeff);
+ static_assert(11 == kIConstC_GrBlendCoeff);
+ static_assert(12 == kConstA_GrBlendCoeff);
+ static_assert(13 == kIConstA_GrBlendCoeff);
- GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
- GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
- GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
- GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
+ static_assert(14 == kS2C_GrBlendCoeff);
+ static_assert(15 == kIS2C_GrBlendCoeff);
+ static_assert(16 == kS2A_GrBlendCoeff);
+ static_assert(17 == kIS2A_GrBlendCoeff);
// assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
- GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gXfermodeCoeff2Blend));
+ static_assert(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gXfermodeCoeff2Blend));
}
//////////////////////////////////////////////////////////////////////////////
@@ -405,7 +405,7 @@
for (int i = 0; i < kGrGpuBufferTypeCount; ++i) {
fHWBufferState[i].invalidate();
}
- GR_STATIC_ASSERT(4 == SK_ARRAY_COUNT(fHWBufferState));
+ static_assert(4 == SK_ARRAY_COUNT(fHWBufferState));
if (this->glCaps().shaderCaps()->pathRenderingSupport()) {
fPathRendering.reset(new GrGLPathRendering(this));
@@ -2397,14 +2397,14 @@
GR_GL_INCR, // kIncClamp
GR_GL_DECR, // kDecClamp
};
- GR_STATIC_ASSERT(0 == (int)GrStencilOp::kKeep);
- GR_STATIC_ASSERT(1 == (int)GrStencilOp::kZero);
- GR_STATIC_ASSERT(2 == (int)GrStencilOp::kReplace);
- GR_STATIC_ASSERT(3 == (int)GrStencilOp::kInvert);
- GR_STATIC_ASSERT(4 == (int)GrStencilOp::kIncWrap);
- GR_STATIC_ASSERT(5 == (int)GrStencilOp::kDecWrap);
- GR_STATIC_ASSERT(6 == (int)GrStencilOp::kIncClamp);
- GR_STATIC_ASSERT(7 == (int)GrStencilOp::kDecClamp);
+ static_assert(0 == (int)GrStencilOp::kKeep);
+ static_assert(1 == (int)GrStencilOp::kZero);
+ static_assert(2 == (int)GrStencilOp::kReplace);
+ static_assert(3 == (int)GrStencilOp::kInvert);
+ static_assert(4 == (int)GrStencilOp::kIncWrap);
+ static_assert(5 == (int)GrStencilOp::kDecWrap);
+ static_assert(6 == (int)GrStencilOp::kIncClamp);
+ static_assert(7 == (int)GrStencilOp::kDecClamp);
SkASSERT(op < (GrStencilOp)kGrStencilOpCount);
return gTable[(int)op];
}
@@ -2691,7 +2691,7 @@
get_gl_swizzle_values(swizzle, glValues);
this->setTextureUnit(unitIdx);
if (GR_IS_GR_GL(this->glStandard())) {
- GR_STATIC_ASSERT(sizeof(glValues[0]) == sizeof(GrGLint));
+ static_assert(sizeof(glValues[0]) == sizeof(GrGLint));
GL_CALL(TexParameteriv(target, GR_GL_TEXTURE_SWIZZLE_RGBA,
reinterpret_cast<const GrGLint*>(glValues)));
} else if (GR_IS_GR_GL_ES(this->glStandard())) {
@@ -3897,7 +3897,7 @@
SkASSERT(this->caps()->fenceSyncSupport());
GrGLsync sync;
GL_CALL_RET(sync, FenceSync(GR_GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
- GR_STATIC_ASSERT(sizeof(GrFence) >= sizeof(GrGLsync));
+ static_assert(sizeof(GrFence) >= sizeof(GrGLsync));
return (GrFence)sync;
}
diff --git a/src/gpu/gl/GrGLPath.cpp b/src/gpu/gl/GrGLPath.cpp
index 798d8fd..edcf1be 100644
--- a/src/gpu/gl/GrGLPath.cpp
+++ b/src/gpu/gl/GrGLPath.cpp
@@ -20,12 +20,12 @@
GR_GL_CUBIC_CURVE_TO,
GR_GL_CLOSE_PATH,
};
- GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
- GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
- GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
- GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
- GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
- GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
+ static_assert(0 == SkPath::kMove_Verb);
+ static_assert(1 == SkPath::kLine_Verb);
+ static_assert(2 == SkPath::kQuad_Verb);
+ static_assert(3 == SkPath::kConic_Verb);
+ static_assert(4 == SkPath::kCubic_Verb);
+ static_assert(5 == SkPath::kClose_Verb);
SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
return gTable[verb];
@@ -41,12 +41,12 @@
6, // cubic
0, // close
};
- GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
- GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
- GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
- GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
- GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
- GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
+ static_assert(0 == SkPath::kMove_Verb);
+ static_assert(1 == SkPath::kLine_Verb);
+ static_assert(2 == SkPath::kQuad_Verb);
+ static_assert(3 == SkPath::kConic_Verb);
+ static_assert(4 == SkPath::kCubic_Verb);
+ static_assert(5 == SkPath::kClose_Verb);
SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
return gTable[verb];
@@ -60,10 +60,10 @@
GR_GL_BEVEL
};
return gSkJoinsToGrGLJoins[join];
- GR_STATIC_ASSERT(0 == SkPaint::kMiter_Join);
- GR_STATIC_ASSERT(1 == SkPaint::kRound_Join);
- GR_STATIC_ASSERT(2 == SkPaint::kBevel_Join);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkJoinsToGrGLJoins) == SkPaint::kJoinCount);
+ static_assert(0 == SkPaint::kMiter_Join);
+ static_assert(1 == SkPaint::kRound_Join);
+ static_assert(2 == SkPaint::kBevel_Join);
+ static_assert(SK_ARRAY_COUNT(gSkJoinsToGrGLJoins) == SkPaint::kJoinCount);
}
inline GrGLenum cap_to_gl_cap(SkPaint::Cap cap) {
@@ -73,10 +73,10 @@
GR_GL_SQUARE
};
return gSkCapsToGrGLCaps[cap];
- GR_STATIC_ASSERT(0 == SkPaint::kButt_Cap);
- GR_STATIC_ASSERT(1 == SkPaint::kRound_Cap);
- GR_STATIC_ASSERT(2 == SkPaint::kSquare_Cap);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
+ static_assert(0 == SkPaint::kButt_Cap);
+ static_assert(1 == SkPaint::kRound_Cap);
+ static_assert(2 == SkPaint::kSquare_Cap);
+ static_assert(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
}
#ifdef SK_DEBUG
diff --git a/src/gpu/gl/GrGLPathRendering.cpp b/src/gpu/gl/GrGLPathRendering.cpp
index 3d16543..b5bdf93 100644
--- a/src/gpu/gl/GrGLPathRendering.cpp
+++ b/src/gpu/gl/GrGLPathRendering.cpp
@@ -23,12 +23,12 @@
// implementation. The call has a result value, and thus waiting for the call completion is needed.
static const GrGLsizei kPathIDPreallocationAmount = 65536;
-GR_STATIC_ASSERT(0 == GrPathRendering::kNone_PathTransformType);
-GR_STATIC_ASSERT(1 == GrPathRendering::kTranslateX_PathTransformType);
-GR_STATIC_ASSERT(2 == GrPathRendering::kTranslateY_PathTransformType);
-GR_STATIC_ASSERT(3 == GrPathRendering::kTranslate_PathTransformType);
-GR_STATIC_ASSERT(4 == GrPathRendering::kAffine_PathTransformType);
-GR_STATIC_ASSERT(GrPathRendering::kAffine_PathTransformType == GrPathRendering::kLast_PathTransformType);
+static_assert(0 == GrPathRendering::kNone_PathTransformType);
+static_assert(1 == GrPathRendering::kTranslateX_PathTransformType);
+static_assert(2 == GrPathRendering::kTranslateY_PathTransformType);
+static_assert(3 == GrPathRendering::kTranslate_PathTransformType);
+static_assert(4 == GrPathRendering::kAffine_PathTransformType);
+static_assert(GrPathRendering::kAffine_PathTransformType == GrPathRendering::kLast_PathTransformType);
#ifdef SK_DEBUG
diff --git a/src/gpu/gl/GrGLUtil.cpp b/src/gpu/gl/GrGLUtil.cpp
index ae5529b..dc8cbe3 100644
--- a/src/gpu/gl/GrGLUtil.cpp
+++ b/src/gpu/gl/GrGLUtil.cpp
@@ -603,14 +603,14 @@
GR_GL_EQUAL, // kEqual
GR_GL_NOTEQUAL, // kNotEqual
};
- GR_STATIC_ASSERT(0 == (int)GrStencilTest::kAlways);
- GR_STATIC_ASSERT(1 == (int)GrStencilTest::kNever);
- GR_STATIC_ASSERT(2 == (int)GrStencilTest::kGreater);
- GR_STATIC_ASSERT(3 == (int)GrStencilTest::kGEqual);
- GR_STATIC_ASSERT(4 == (int)GrStencilTest::kLess);
- GR_STATIC_ASSERT(5 == (int)GrStencilTest::kLEqual);
- GR_STATIC_ASSERT(6 == (int)GrStencilTest::kEqual);
- GR_STATIC_ASSERT(7 == (int)GrStencilTest::kNotEqual);
+ static_assert(0 == (int)GrStencilTest::kAlways);
+ static_assert(1 == (int)GrStencilTest::kNever);
+ static_assert(2 == (int)GrStencilTest::kGreater);
+ static_assert(3 == (int)GrStencilTest::kGEqual);
+ static_assert(4 == (int)GrStencilTest::kLess);
+ static_assert(5 == (int)GrStencilTest::kLEqual);
+ static_assert(6 == (int)GrStencilTest::kEqual);
+ static_assert(7 == (int)GrStencilTest::kNotEqual);
SkASSERT(test < (GrStencilTest)kGrStencilTestCount);
return gTable[(int)test];
diff --git a/src/gpu/gl/GrGLVertexArray.cpp b/src/gpu/gl/GrGLVertexArray.cpp
index cfac573..d263dce 100644
--- a/src/gpu/gl/GrGLVertexArray.cpp
+++ b/src/gpu/gl/GrGLVertexArray.cpp
@@ -16,7 +16,7 @@
uint16_t fType;
};
-GR_STATIC_ASSERT(4 == sizeof(AttribLayout));
+static_assert(4 == sizeof(AttribLayout));
static AttribLayout attrib_layout(GrVertexAttribType type) {
switch (type) {
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index 5976330..0d9e467 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -38,32 +38,32 @@
};
return kLayoutQualifierNames[equation - kFirstAdvancedGrBlendEquation];
- GR_STATIC_ASSERT(0 == kScreen_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(1 == kOverlay_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(2 == kDarken_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(3 == kLighten_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(4 == kColorDodge_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(5 == kColorBurn_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(6 == kHardLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(7 == kSoftLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(8 == kDifference_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(9 == kExclusion_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(10 == kMultiply_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(11 == kHSLHue_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(12 == kHSLSaturation_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(13 == kHSLColor_GrBlendEquation - kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(14 == kHSLLuminosity_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(0 == kScreen_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(1 == kOverlay_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(2 == kDarken_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(3 == kLighten_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(4 == kColorDodge_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(5 == kColorBurn_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(6 == kHardLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(7 == kSoftLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(8 == kDifference_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(9 == kExclusion_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(10 == kMultiply_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(11 == kHSLHue_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(12 == kHSLSaturation_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(13 == kHSLColor_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+ static_assert(14 == kHSLLuminosity_GrBlendEquation - kFirstAdvancedGrBlendEquation);
// There's an illegal GrBlendEquation at the end there, hence the -1.
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(kLayoutQualifierNames) ==
- kGrBlendEquationCnt - kFirstAdvancedGrBlendEquation - 1);
+ static_assert(SK_ARRAY_COUNT(kLayoutQualifierNames) ==
+ kGrBlendEquationCnt - kFirstAdvancedGrBlendEquation - 1);
}
uint8_t GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(GrSurfaceOrigin origin) {
SkASSERT(kTopLeft_GrSurfaceOrigin == origin || kBottomLeft_GrSurfaceOrigin == origin);
return origin + 1;
- GR_STATIC_ASSERT(0 == kTopLeft_GrSurfaceOrigin);
- GR_STATIC_ASSERT(1 == kBottomLeft_GrSurfaceOrigin);
+ static_assert(0 == kTopLeft_GrSurfaceOrigin);
+ static_assert(1 == kBottomLeft_GrSurfaceOrigin);
}
GrGLSLFragmentShaderBuilder::GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program)
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.cpp b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
index b1e5499..4ef839a 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
@@ -254,9 +254,9 @@
this->layoutQualifiers().appendf(") %s;\n", interfaceQualifierNames[interface]);
}
- GR_STATIC_ASSERT(0 == GrGLSLShaderBuilder::kIn_InterfaceQualifier);
- GR_STATIC_ASSERT(1 == GrGLSLShaderBuilder::kOut_InterfaceQualifier);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(interfaceQualifierNames) == kLastInterfaceQualifier + 1);
+ static_assert(0 == GrGLSLShaderBuilder::kIn_InterfaceQualifier);
+ static_assert(1 == GrGLSLShaderBuilder::kOut_InterfaceQualifier);
+ static_assert(SK_ARRAY_COUNT(interfaceQualifierNames) == kLastInterfaceQualifier + 1);
}
void GrGLSLShaderBuilder::finalize(uint32_t visibility) {
diff --git a/src/gpu/gradients/GrLinearGradientLayout.fp b/src/gpu/gradients/GrLinearGradientLayout.fp
index 1b66dc9..fc9ccf1 100644
--- a/src/gpu/gradients/GrLinearGradientLayout.fp
+++ b/src/gpu/gradients/GrLinearGradientLayout.fp
@@ -69,6 +69,6 @@
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
diff --git a/src/gpu/gradients/GrSweepGradientLayout.fp b/src/gpu/gradients/GrSweepGradientLayout.fp
index 09c1e60..b2894fd 100644
--- a/src/gpu/gradients/GrSweepGradientLayout.fp
+++ b/src/gpu/gradients/GrSweepGradientLayout.fp
@@ -78,6 +78,6 @@
params.fStops, params.fColorCount);
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
diff --git a/src/gpu/gradients/GrTwoPointConicalGradientLayout.fp b/src/gpu/gradients/GrTwoPointConicalGradientLayout.fp
index 3192213..8975f6d 100644
--- a/src/gpu/gradients/GrTwoPointConicalGradientLayout.fp
+++ b/src/gpu/gradients/GrTwoPointConicalGradientLayout.fp
@@ -297,6 +297,6 @@
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
diff --git a/src/gpu/gradients/generated/GrLinearGradientLayout.cpp b/src/gpu/gradients/generated/GrLinearGradientLayout.cpp
index c5e70d6..b4da70d 100644
--- a/src/gpu/gradients/generated/GrLinearGradientLayout.cpp
+++ b/src/gpu/gradients/generated/GrLinearGradientLayout.cpp
@@ -73,7 +73,7 @@
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
#endif
diff --git a/src/gpu/gradients/generated/GrSweepGradientLayout.cpp b/src/gpu/gradients/generated/GrSweepGradientLayout.cpp
index 5b5f04a..d62046f 100644
--- a/src/gpu/gradients/generated/GrSweepGradientLayout.cpp
+++ b/src/gpu/gradients/generated/GrSweepGradientLayout.cpp
@@ -107,7 +107,7 @@
params.fStops, params.fColorCount);
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
#endif
diff --git a/src/gpu/gradients/generated/GrTwoPointConicalGradientLayout.cpp b/src/gpu/gradients/generated/GrTwoPointConicalGradientLayout.cpp
index 235a137..69d4d76 100644
--- a/src/gpu/gradients/generated/GrTwoPointConicalGradientLayout.cpp
+++ b/src/gpu/gradients/generated/GrTwoPointConicalGradientLayout.cpp
@@ -222,7 +222,7 @@
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
- GrAlwaysAssert(fp);
+ SkASSERT_RELEASE(fp);
return fp;
}
#endif
diff --git a/src/gpu/mtl/GrMtlOpsRenderPass.mm b/src/gpu/mtl/GrMtlOpsRenderPass.mm
index 39110df..f38b066 100644
--- a/src/gpu/mtl/GrMtlOpsRenderPass.mm
+++ b/src/gpu/mtl/GrMtlOpsRenderPass.mm
@@ -181,9 +181,9 @@
MTLLoadActionClear,
MTLLoadActionDontCare
};
- GR_STATIC_ASSERT((int)GrLoadOp::kLoad == 0);
- GR_STATIC_ASSERT((int)GrLoadOp::kClear == 1);
- GR_STATIC_ASSERT((int)GrLoadOp::kDiscard == 2);
+ static_assert((int)GrLoadOp::kLoad == 0);
+ static_assert((int)GrLoadOp::kClear == 1);
+ static_assert((int)GrLoadOp::kDiscard == 2);
SkASSERT(colorInfo.fLoadOp <= GrLoadOp::kDiscard);
SkASSERT(stencilInfo.fLoadOp <= GrLoadOp::kDiscard);
@@ -191,8 +191,8 @@
MTLStoreActionStore,
MTLStoreActionDontCare
};
- GR_STATIC_ASSERT((int)GrStoreOp::kStore == 0);
- GR_STATIC_ASSERT((int)GrStoreOp::kDiscard == 1);
+ static_assert((int)GrStoreOp::kStore == 0);
+ static_assert((int)GrStoreOp::kDiscard == 1);
SkASSERT(colorInfo.fStoreOp <= GrStoreOp::kDiscard);
SkASSERT(stencilInfo.fStoreOp <= GrStoreOp::kDiscard);
@@ -246,11 +246,11 @@
MTLPrimitiveTypeLine,
MTLPrimitiveTypeLineStrip
};
- GR_STATIC_ASSERT((int)GrPrimitiveType::kTriangles == 0);
- GR_STATIC_ASSERT((int)GrPrimitiveType::kTriangleStrip == 1);
- GR_STATIC_ASSERT((int)GrPrimitiveType::kPoints == 2);
- GR_STATIC_ASSERT((int)GrPrimitiveType::kLines == 3);
- GR_STATIC_ASSERT((int)GrPrimitiveType::kLineStrip == 4);
+ static_assert((int)GrPrimitiveType::kTriangles == 0);
+ static_assert((int)GrPrimitiveType::kTriangleStrip == 1);
+ static_assert((int)GrPrimitiveType::kPoints == 2);
+ static_assert((int)GrPrimitiveType::kLines == 3);
+ static_assert((int)GrPrimitiveType::kLineStrip == 4);
SkASSERT(primitiveType <= GrPrimitiveType::kLineStrip);
return mtlPrimitiveType[static_cast<int>(primitiveType)];
diff --git a/src/gpu/mtl/GrMtlPipelineStateBuilder.mm b/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
index dc98db2..a0e8625 100644
--- a/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
+++ b/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
@@ -286,10 +286,10 @@
MTLBlendOperationSubtract, // kSubtract_GrBlendEquation
MTLBlendOperationReverseSubtract, // kReverseSubtract_GrBlendEquation
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kFirstAdvancedGrBlendEquation);
- GR_STATIC_ASSERT(0 == kAdd_GrBlendEquation);
- GR_STATIC_ASSERT(1 == kSubtract_GrBlendEquation);
- GR_STATIC_ASSERT(2 == kReverseSubtract_GrBlendEquation);
+ static_assert(SK_ARRAY_COUNT(gTable) == kFirstAdvancedGrBlendEquation);
+ static_assert(0 == kAdd_GrBlendEquation);
+ static_assert(1 == kSubtract_GrBlendEquation);
+ static_assert(2 == kReverseSubtract_GrBlendEquation);
SkASSERT((unsigned)equation < kGrBlendEquationCnt);
return gTable[equation];
diff --git a/src/gpu/mtl/GrMtlPipelineStateDataManager.mm b/src/gpu/mtl/GrMtlPipelineStateDataManager.mm
index 1f2af24..81a06e2 100644
--- a/src/gpu/mtl/GrMtlPipelineStateDataManager.mm
+++ b/src/gpu/mtl/GrMtlPipelineStateDataManager.mm
@@ -299,7 +299,7 @@
template<> struct set_uniform_matrix<2> {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
memcpy(buffer, matrices, count * 4 * sizeof(float));
}
@@ -307,7 +307,7 @@
template<> struct set_uniform_matrix<3> {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
for (int i = 0; i < count; ++i) {
const float* matrix = &matrices[3 * 3 * i];
@@ -321,7 +321,7 @@
template<> struct set_uniform_matrix<4> {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
memcpy(buffer, matrices, count * 16 * sizeof(float));
}
diff --git a/src/gpu/mtl/GrMtlSampler.mm b/src/gpu/mtl/GrMtlSampler.mm
index 2d7344e..365c505 100644
--- a/src/gpu/mtl/GrMtlSampler.mm
+++ b/src/gpu/mtl/GrMtlSampler.mm
@@ -47,9 +47,9 @@
MTLSamplerMinMagFilterLinear
};
- GR_STATIC_ASSERT((int)GrSamplerState::Filter::kNearest == 0);
- GR_STATIC_ASSERT((int)GrSamplerState::Filter::kBilerp == 1);
- GR_STATIC_ASSERT((int)GrSamplerState::Filter::kMipMap == 2);
+ static_assert((int)GrSamplerState::Filter::kNearest == 0);
+ static_assert((int)GrSamplerState::Filter::kBilerp == 1);
+ static_assert((int)GrSamplerState::Filter::kMipMap == 2);
auto samplerDesc = [[MTLSamplerDescriptor alloc] init];
samplerDesc.rAddressMode = MTLSamplerAddressModeClampToEdge;
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 9efdd3a..2e71924 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -48,15 +48,15 @@
SkVector fMid;
int countPoints() {
- GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
+ static_assert(0 == kLine && 1 == kQuad);
return fType + 1;
}
const SkPoint& endPt() const {
- GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
+ static_assert(0 == kLine && 1 == kQuad);
return fPts[fType];
}
const SkPoint& endNorm() const {
- GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
+ static_assert(0 == kLine && 1 == kQuad);
return fNorms[fType];
}
};
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index b41a968..67189b0 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -111,7 +111,7 @@
// Takes 178th time of logf on Z600 / VC2010
static int get_float_exp(float x) {
- GR_STATIC_ASSERT(sizeof(int) == sizeof(float));
+ static_assert(sizeof(int) == sizeof(float));
#ifdef SK_DEBUG
static bool tested;
if (!tested) {
@@ -487,7 +487,7 @@
};
};
-GR_STATIC_ASSERT(sizeof(BezierVertex) == 3 * sizeof(SkPoint));
+static_assert(sizeof(BezierVertex) == 3 * sizeof(SkPoint));
static void intersect_lines(const SkPoint& ptA, const SkVector& normA,
const SkPoint& ptB, const SkVector& normB,
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index d425b71..ca96573 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -298,8 +298,8 @@
SkASSERT(proxies[0]);
static constexpr int kMaxTextures = GrBitmapTextGeoProc::kMaxTextures;
- GR_STATIC_ASSERT(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
- GR_STATIC_ASSERT(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
+ static_assert(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
+ static_assert(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
auto fixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
for (unsigned i = 0; i < numActiveProxies; ++i) {
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index cc78057..d082313 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -198,7 +198,7 @@
op = SkRegion::kReplace_Op;
} else {
// Pick an other than replace.
- GR_STATIC_ASSERT(SkRegion::kLastOp == SkRegion::kReplace_Op);
+ static_assert(SkRegion::kLastOp == SkRegion::kReplace_Op);
op = (SkRegion::Op)random->nextULessThan(SkRegion::kLastOp);
}
region.op(rect, op);
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 742aa58..7f313e5 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -319,7 +319,7 @@
int instanceCount = fShapes.count();
static constexpr int kMaxTextures = GrDistanceFieldPathGeoProc::kMaxTextures;
- GR_STATIC_ASSERT(GrBitmapTextGeoProc::kMaxTextures == kMaxTextures);
+ static_assert(GrBitmapTextGeoProc::kMaxTextures == kMaxTextures);
FlushInfo flushInfo;
flushInfo.fFixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
diff --git a/src/gpu/ops/GrStrokeRectOp.cpp b/src/gpu/ops/GrStrokeRectOp.cpp
index 6c95eae..acaa25d 100644
--- a/src/gpu/ops/GrStrokeRectOp.cpp
+++ b/src/gpu/ops/GrStrokeRectOp.cpp
@@ -544,7 +544,7 @@
3 + 8, 0 + 8, 4 + 8, 4 + 8, 7 + 8, 3 + 8,
};
// clang-format on
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gMiterIndices) == kMiterIndexCnt);
+ static_assert(SK_ARRAY_COUNT(gMiterIndices) == kMiterIndexCnt);
GR_DEFINE_STATIC_UNIQUE_KEY(gMiterIndexBufferKey);
return resourceProvider->findOrCreatePatternedIndexBuffer(
gMiterIndices, kMiterIndexCnt, kNumMiterRectsInIndexBuffer, kMiterVertexCnt,
@@ -608,7 +608,7 @@
3 + 16, 0 + 16, 4 + 16, 4 + 16, 7 + 16, 3 + 16,
};
// clang-format on
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gBevelIndices) == kBevelIndexCnt);
+ static_assert(SK_ARRAY_COUNT(gBevelIndices) == kBevelIndexCnt);
GR_DEFINE_STATIC_UNIQUE_KEY(gBevelIndexBufferKey);
return resourceProvider->findOrCreatePatternedIndexBuffer(
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index f2dd15b..7d8bf41 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -2543,7 +2543,7 @@
return 0;
}
- GR_STATIC_ASSERT(sizeof(GrFence) >= sizeof(VkFence));
+ static_assert(sizeof(GrFence) >= sizeof(VkFence));
return (GrFence)fence;
}
diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp
index d3ab9ef..fcaa521 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -188,15 +188,15 @@
VK_STENCIL_OP_INCREMENT_AND_CLAMP, // kIncClamp
VK_STENCIL_OP_DECREMENT_AND_CLAMP, // kDecClamp
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrStencilOpCount);
- GR_STATIC_ASSERT(0 == (int)GrStencilOp::kKeep);
- GR_STATIC_ASSERT(1 == (int)GrStencilOp::kZero);
- GR_STATIC_ASSERT(2 == (int)GrStencilOp::kReplace);
- GR_STATIC_ASSERT(3 == (int)GrStencilOp::kInvert);
- GR_STATIC_ASSERT(4 == (int)GrStencilOp::kIncWrap);
- GR_STATIC_ASSERT(5 == (int)GrStencilOp::kDecWrap);
- GR_STATIC_ASSERT(6 == (int)GrStencilOp::kIncClamp);
- GR_STATIC_ASSERT(7 == (int)GrStencilOp::kDecClamp);
+ static_assert(SK_ARRAY_COUNT(gTable) == kGrStencilOpCount);
+ static_assert(0 == (int)GrStencilOp::kKeep);
+ static_assert(1 == (int)GrStencilOp::kZero);
+ static_assert(2 == (int)GrStencilOp::kReplace);
+ static_assert(3 == (int)GrStencilOp::kInvert);
+ static_assert(4 == (int)GrStencilOp::kIncWrap);
+ static_assert(5 == (int)GrStencilOp::kDecWrap);
+ static_assert(6 == (int)GrStencilOp::kIncClamp);
+ static_assert(7 == (int)GrStencilOp::kDecClamp);
SkASSERT(op < (GrStencilOp)kGrStencilOpCount);
return gTable[(int)op];
}
@@ -212,15 +212,15 @@
VK_COMPARE_OP_EQUAL, // kEqual
VK_COMPARE_OP_NOT_EQUAL, // kNotEqual
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrStencilTestCount);
- GR_STATIC_ASSERT(0 == (int)GrStencilTest::kAlways);
- GR_STATIC_ASSERT(1 == (int)GrStencilTest::kNever);
- GR_STATIC_ASSERT(2 == (int)GrStencilTest::kGreater);
- GR_STATIC_ASSERT(3 == (int)GrStencilTest::kGEqual);
- GR_STATIC_ASSERT(4 == (int)GrStencilTest::kLess);
- GR_STATIC_ASSERT(5 == (int)GrStencilTest::kLEqual);
- GR_STATIC_ASSERT(6 == (int)GrStencilTest::kEqual);
- GR_STATIC_ASSERT(7 == (int)GrStencilTest::kNotEqual);
+ static_assert(SK_ARRAY_COUNT(gTable) == kGrStencilTestCount);
+ static_assert(0 == (int)GrStencilTest::kAlways);
+ static_assert(1 == (int)GrStencilTest::kNever);
+ static_assert(2 == (int)GrStencilTest::kGreater);
+ static_assert(3 == (int)GrStencilTest::kGEqual);
+ static_assert(4 == (int)GrStencilTest::kLess);
+ static_assert(5 == (int)GrStencilTest::kLEqual);
+ static_assert(6 == (int)GrStencilTest::kEqual);
+ static_assert(7 == (int)GrStencilTest::kNotEqual);
SkASSERT(test < (GrStencilTest)kGrStencilTestCount);
return gTable[(int)test];
@@ -355,25 +355,25 @@
VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, // kIS2A_GrBlendCoeff
VK_BLEND_FACTOR_ZERO, // kIllegal_GrBlendCoeff
};
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrBlendCoeffCnt);
- GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
- GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
- GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
- GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
- GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
- GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
- GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
- GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
- GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
- GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
- GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
- GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
- GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
- GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
- GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
- GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
- GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
- GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
+ static_assert(SK_ARRAY_COUNT(gTable) == kGrBlendCoeffCnt);
+ static_assert(0 == kZero_GrBlendCoeff);
+ static_assert(1 == kOne_GrBlendCoeff);
+ static_assert(2 == kSC_GrBlendCoeff);
+ static_assert(3 == kISC_GrBlendCoeff);
+ static_assert(4 == kDC_GrBlendCoeff);
+ static_assert(5 == kIDC_GrBlendCoeff);
+ static_assert(6 == kSA_GrBlendCoeff);
+ static_assert(7 == kISA_GrBlendCoeff);
+ static_assert(8 == kDA_GrBlendCoeff);
+ static_assert(9 == kIDA_GrBlendCoeff);
+ static_assert(10 == kConstC_GrBlendCoeff);
+ static_assert(11 == kIConstC_GrBlendCoeff);
+ static_assert(12 == kConstA_GrBlendCoeff);
+ static_assert(13 == kIConstA_GrBlendCoeff);
+ static_assert(14 == kS2C_GrBlendCoeff);
+ static_assert(15 == kIS2C_GrBlendCoeff);
+ static_assert(16 == kS2A_GrBlendCoeff);
+ static_assert(17 == kIS2A_GrBlendCoeff);
SkASSERT((unsigned)coeff < kGrBlendCoeffCnt);
return gTable[coeff];
@@ -407,25 +407,25 @@
// Illegal.
VK_BLEND_OP_ADD,
};
- GR_STATIC_ASSERT(0 == kAdd_GrBlendEquation);
- GR_STATIC_ASSERT(1 == kSubtract_GrBlendEquation);
- GR_STATIC_ASSERT(2 == kReverseSubtract_GrBlendEquation);
- GR_STATIC_ASSERT(3 == kScreen_GrBlendEquation);
- GR_STATIC_ASSERT(4 == kOverlay_GrBlendEquation);
- GR_STATIC_ASSERT(5 == kDarken_GrBlendEquation);
- GR_STATIC_ASSERT(6 == kLighten_GrBlendEquation);
- GR_STATIC_ASSERT(7 == kColorDodge_GrBlendEquation);
- GR_STATIC_ASSERT(8 == kColorBurn_GrBlendEquation);
- GR_STATIC_ASSERT(9 == kHardLight_GrBlendEquation);
- GR_STATIC_ASSERT(10 == kSoftLight_GrBlendEquation);
- GR_STATIC_ASSERT(11 == kDifference_GrBlendEquation);
- GR_STATIC_ASSERT(12 == kExclusion_GrBlendEquation);
- GR_STATIC_ASSERT(13 == kMultiply_GrBlendEquation);
- GR_STATIC_ASSERT(14 == kHSLHue_GrBlendEquation);
- GR_STATIC_ASSERT(15 == kHSLSaturation_GrBlendEquation);
- GR_STATIC_ASSERT(16 == kHSLColor_GrBlendEquation);
- GR_STATIC_ASSERT(17 == kHSLLuminosity_GrBlendEquation);
- GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrBlendEquationCnt);
+ static_assert(0 == kAdd_GrBlendEquation);
+ static_assert(1 == kSubtract_GrBlendEquation);
+ static_assert(2 == kReverseSubtract_GrBlendEquation);
+ static_assert(3 == kScreen_GrBlendEquation);
+ static_assert(4 == kOverlay_GrBlendEquation);
+ static_assert(5 == kDarken_GrBlendEquation);
+ static_assert(6 == kLighten_GrBlendEquation);
+ static_assert(7 == kColorDodge_GrBlendEquation);
+ static_assert(8 == kColorBurn_GrBlendEquation);
+ static_assert(9 == kHardLight_GrBlendEquation);
+ static_assert(10 == kSoftLight_GrBlendEquation);
+ static_assert(11 == kDifference_GrBlendEquation);
+ static_assert(12 == kExclusion_GrBlendEquation);
+ static_assert(13 == kMultiply_GrBlendEquation);
+ static_assert(14 == kHSLHue_GrBlendEquation);
+ static_assert(15 == kHSLSaturation_GrBlendEquation);
+ static_assert(16 == kHSLColor_GrBlendEquation);
+ static_assert(17 == kHSLLuminosity_GrBlendEquation);
+ static_assert(SK_ARRAY_COUNT(gTable) == kGrBlendEquationCnt);
SkASSERT((unsigned)equation < kGrBlendCoeffCnt);
return gTable[equation];
@@ -458,7 +458,7 @@
false,
};
return gCoeffReferencesBlendConst[coeff];
- GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
+ static_assert(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
// Individual enum asserts already made in blend_coeff_to_vk_blend
}
diff --git a/src/gpu/vk/GrVkPipelineStateDataManager.cpp b/src/gpu/vk/GrVkPipelineStateDataManager.cpp
index cbef926..6d9393c 100644
--- a/src/gpu/vk/GrVkPipelineStateDataManager.cpp
+++ b/src/gpu/vk/GrVkPipelineStateDataManager.cpp
@@ -313,7 +313,7 @@
template<int N> struct set_uniform_matrix {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
for (int i = 0; i < count; ++i) {
const float* matrix = &matrices[N * N * i];
@@ -327,7 +327,7 @@
template<> struct set_uniform_matrix<4> {
inline static void set(void* buffer, int uniformOffset, int count, const float matrices[]) {
- GR_STATIC_ASSERT(sizeof(float) == 4);
+ static_assert(sizeof(float) == 4);
buffer = static_cast<char*>(buffer) + uniformOffset;
memcpy(buffer, matrices, count * 16 * sizeof(float));
}
diff --git a/src/gpu/vk/GrVkSamplerYcbcrConversion.cpp b/src/gpu/vk/GrVkSamplerYcbcrConversion.cpp
index ec0c22d..dda7ae6 100644
--- a/src/gpu/vk/GrVkSamplerYcbcrConversion.cpp
+++ b/src/gpu/vk/GrVkSamplerYcbcrConversion.cpp
@@ -100,7 +100,7 @@
SkASSERT(static_cast<int>(ycbcrInfo.fChromaFilter) <= 1);
static const int kReconShift = kChromaFilterShift + 1;
SkASSERT(static_cast<int>(ycbcrInfo.fForceExplicitReconstruction) <= 1);
- GR_STATIC_ASSERT(kReconShift <= 7);
+ static_assert(kReconShift <= 7);
uint8_t ycbcrKey = static_cast<uint8_t>(ycbcrInfo.fYcbcrModel);
ycbcrKey |= (static_cast<uint8_t>(ycbcrInfo.fYcbcrRange) << kRangeShift);
diff --git a/tests/BackendAllocationTest.cpp b/tests/BackendAllocationTest.cpp
index 34aee51..226ffab 100644
--- a/tests/BackendAllocationTest.cpp
+++ b/tests/BackendAllocationTest.cpp
@@ -597,7 +597,7 @@
{ kR16G16B16A16_unorm_SkColorType,{ .25f, .5f, .75f, 1 } },
};
- GR_STATIC_ASSERT(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
+ static_assert(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
for (auto combo : combinations) {
SkColorType colorType = combo.fColorType;
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 21f57fb..370a1e2 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -1048,7 +1048,7 @@
// will be kInvalidGenID if left uninitialized.
SkAlignedSTStorage<1, GrReducedClip> storage;
memset(storage.get(), 0, sizeof(GrReducedClip));
- GR_STATIC_ASSERT(0 == SkClipStack::kInvalidGenID);
+ static_assert(0 == SkClipStack::kInvalidGenID);
// Get the reduced version of the stack.
SkRect queryBounds = kBounds;
@@ -1117,7 +1117,7 @@
SkAlignedSTStorage<1, GrReducedClip> storage;
memset(storage.get(), 0, sizeof(GrReducedClip));
- GR_STATIC_ASSERT(0 == SkClipStack::kInvalidGenID);
+ static_assert(0 == SkClipStack::kInvalidGenID);
const GrReducedClip* reduced = new (storage.get()) GrReducedClip(stack, bounds, caps);
REPORTER_ASSERT(reporter, reduced->maskElements().count() == 1);
diff --git a/tests/GrMeshTest.cpp b/tests/GrMeshTest.cpp
index b2338e5..7580b11 100644
--- a/tests/GrMeshTest.cpp
+++ b/tests/GrMeshTest.cpp
@@ -179,7 +179,7 @@
// Start at various repetitions within the patterned index buffer to exercise base
// index.
while (i < kBoxCount) {
- GR_STATIC_ASSERT(kIndexPatternRepeatCount >= 3);
+ static_assert(kIndexPatternRepeatCount >= 3);
int repetitionCount = SkTMin(3 - baseRepetition, kBoxCount - i);
GrMesh mesh(GrPrimitiveType::kTriangles);
diff --git a/tests/GrShapeTest.cpp b/tests/GrShapeTest.cpp
index 01bb540..37e9242 100644
--- a/tests/GrShapeTest.cpp
+++ b/tests/GrShapeTest.cpp
@@ -62,7 +62,7 @@
static constexpr int kRes = 2000;
// This tolerance is in units of 1/kRes fractions of the bounds width/height.
static constexpr int kTol = 2;
- GR_STATIC_ASSERT(kRes % 4 == 0);
+ static_assert(kRes % 4 == 0);
SkImageInfo info = SkImageInfo::MakeA8(kRes, kRes);
sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
surface->getCanvas()->clear(0x0);
diff --git a/tools/gpu/gl/GLTestContext.cpp b/tools/gpu/gl/GLTestContext.cpp
index d4aa605..fad8c4f 100644
--- a/tools/gpu/gl/GLTestContext.cpp
+++ b/tools/gpu/gl/GLTestContext.cpp
@@ -31,7 +31,7 @@
static constexpr GrGLbitfield GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001;
typedef struct __GLsync *GLsync;
- GR_STATIC_ASSERT(sizeof(GLsync) <= sizeof(sk_gpu_test::PlatformFence));
+ static_assert(sizeof(GLsync) <= sizeof(sk_gpu_test::PlatformFence));
typedef GLsync (GR_GL_FUNCTION_TYPE* GLFenceSyncProc) (GrGLenum, GrGLbitfield);
typedef GrGLenum (GR_GL_FUNCTION_TYPE* GLClientWaitSyncProc) (GLsync, GrGLbitfield, GrGLuint64);
@@ -272,7 +272,7 @@
fGLDeleteQueries(1, &queryID);
}
-GR_STATIC_ASSERT(sizeof(GrGLuint) <= sizeof(sk_gpu_test::PlatformTimerQuery));
+static_assert(sizeof(GrGLuint) <= sizeof(sk_gpu_test::PlatformTimerQuery));
} // anonymous namespace
diff --git a/tools/gpu/gl/egl/CreatePlatformGLTestContext_egl.cpp b/tools/gpu/gl/egl/CreatePlatformGLTestContext_egl.cpp
index 96900fd..f69c80f 100644
--- a/tools/gpu/gl/egl/CreatePlatformGLTestContext_egl.cpp
+++ b/tools/gpu/gl/egl/CreatePlatformGLTestContext_egl.cpp
@@ -373,7 +373,7 @@
fEGLDestroySyncKHR(fDisplay, eglsync);
}
-GR_STATIC_ASSERT(sizeof(EGLSyncKHR) <= sizeof(sk_gpu_test::PlatformFence));
+static_assert(sizeof(EGLSyncKHR) <= sizeof(sk_gpu_test::PlatformFence));
} // anonymous namespace
diff --git a/tools/gpu/mtl/MtlTestContext.mm b/tools/gpu/mtl/MtlTestContext.mm
index 367051f..d5ad079 100644
--- a/tools/gpu/mtl/MtlTestContext.mm
+++ b/tools/gpu/mtl/MtlTestContext.mm
@@ -65,7 +65,7 @@
typedef sk_gpu_test::FenceSync INHERITED;
};
-GR_STATIC_ASSERT(sizeof(uint64_t) <= sizeof(sk_gpu_test::PlatformFence));
+static_assert(sizeof(uint64_t) <= sizeof(sk_gpu_test::PlatformFence));
class MtlTestContextImpl : public sk_gpu_test::MtlTestContext {
public:
diff --git a/tools/gpu/vk/VkTestContext.cpp b/tools/gpu/vk/VkTestContext.cpp
index 6215efe..26b23e0 100644
--- a/tools/gpu/vk/VkTestContext.cpp
+++ b/tools/gpu/vk/VkTestContext.cpp
@@ -141,7 +141,7 @@
typedef sk_gpu_test::FenceSync INHERITED;
};
-GR_STATIC_ASSERT(sizeof(VkFence) <= sizeof(sk_gpu_test::PlatformFence));
+static_assert(sizeof(VkFence) <= sizeof(sk_gpu_test::PlatformFence));
// TODO: Implement swap buffers and finish
class VkTestContextImpl : public sk_gpu_test::VkTestContext {