update error reporting function

14 files changed, 160 insertions, 160 deletions

diff --git a/src/mbgl/shader/dot_shader.cpp b/src/mbgl/shader/dot_shader.cpp
index 9874f15efa..08b55a566b 100644
--- a/src/mbgl/shader/dot_shader.cpp
+++ b/src/mbgl/shader/dot_shader.cpp
@@ -17,10 +17,10 @@ DotShader::DotShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void DotShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
 }
diff --git a/src/mbgl/shader/gaussian_shader.cpp b/src/mbgl/shader/gaussian_shader.cpp
index 9569d4047f..483de4867e 100644
--- a/src/mbgl/shader/gaussian_shader.cpp
+++ b/src/mbgl/shader/gaussian_shader.cpp
@@ -19,10 +19,10 @@ GaussianShader::GaussianShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void GaussianShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/icon_shader.cpp b/src/mbgl/shader/icon_shader.cpp
index a50c525b6e..fa397fb274 100644
--- a/src/mbgl/shader/icon_shader.cpp
+++ b/src/mbgl/shader/icon_shader.cpp
@@ -17,44 +17,44 @@ IconShader::IconShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-    a_offset = CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
-    a_tex = CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
-    a_angle = CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
-    a_minzoom = CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
-    a_maxzoom = CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
-    a_rangeend = CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
-    a_rangestart = CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
-    a_labelminzoom = CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_offset = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
+    a_tex = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
+    a_angle = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
+    a_minzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
+    a_maxzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
+    a_rangeend = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
+    a_rangestart = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
+    a_labelminzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
 }
 
 void IconShader::bind(char *offset) {
     const int stride = 20;
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
-    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
-    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
-    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
-    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
-    CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
 }
diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp
index 3d8af9fd01..5ad257eabd 100644
--- a/src/mbgl/shader/line_shader.cpp
+++ b/src/mbgl/shader/line_shader.cpp
@@ -17,18 +17,18 @@ LineShader::LineShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-    a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
-    a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_extrude = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
+    a_linesofar = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
 }
 
 void LineShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
-    CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
-    CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
 }
diff --git a/src/mbgl/shader/linejoin_shader.cpp b/src/mbgl/shader/linejoin_shader.cpp
index 94c00fd0db..5b9e7ba20a 100644
--- a/src/mbgl/shader/linejoin_shader.cpp
+++ b/src/mbgl/shader/linejoin_shader.cpp
@@ -17,11 +17,11 @@ LinejoinShader::LinejoinShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void LinejoinShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     // Note: We're referring to the vertices in a line array, which are 8 bytes long!
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
 }
diff --git a/src/mbgl/shader/linepattern_shader.cpp b/src/mbgl/shader/linepattern_shader.cpp
index 0a4503dd12..492a8f2a85 100644
--- a/src/mbgl/shader/linepattern_shader.cpp
+++ b/src/mbgl/shader/linepattern_shader.cpp
@@ -18,18 +18,18 @@ LinepatternShader::LinepatternShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-    a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
-    a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_extrude = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
+    a_linesofar = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
 }
 
 void LinepatternShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
-    CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
-    CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
 }
diff --git a/src/mbgl/shader/outline_shader.cpp b/src/mbgl/shader/outline_shader.cpp
index ef2f7dccf6..98d208297c 100644
--- a/src/mbgl/shader/outline_shader.cpp
+++ b/src/mbgl/shader/outline_shader.cpp
@@ -17,10 +17,10 @@ OutlineShader::OutlineShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void OutlineShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/pattern_shader.cpp b/src/mbgl/shader/pattern_shader.cpp
index 660c90c20a..0a6013b17d 100644
--- a/src/mbgl/shader/pattern_shader.cpp
+++ b/src/mbgl/shader/pattern_shader.cpp
@@ -17,10 +17,10 @@ PatternShader::PatternShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void PatternShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/plain_shader.cpp b/src/mbgl/shader/plain_shader.cpp
index 4e636309b5..ce7ddae918 100644
--- a/src/mbgl/shader/plain_shader.cpp
+++ b/src/mbgl/shader/plain_shader.cpp
@@ -17,10 +17,10 @@ PlainShader::PlainShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void PlainShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp
index b9cdaed6b9..14c6ddc7c4 100644
--- a/src/mbgl/shader/raster_shader.cpp
+++ b/src/mbgl/shader/raster_shader.cpp
@@ -19,10 +19,10 @@ RasterShader::RasterShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void RasterShader::bind(char *offset) {
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/sdf_shader.cpp b/src/mbgl/shader/sdf_shader.cpp
index 05541ce4e9..25b226ee23 100644
--- a/src/mbgl/shader/sdf_shader.cpp
+++ b/src/mbgl/shader/sdf_shader.cpp
@@ -17,75 +17,75 @@ SDFShader::SDFShader()
         return;
     }
 
-    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-    a_offset = CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
-    a_tex = CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
-    a_angle = CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
-    a_minzoom = CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
-    a_maxzoom = CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
-    a_rangeend = CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
-    a_rangestart = CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
-    a_labelminzoom = CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
+    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_offset = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
+    a_tex = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
+    a_angle = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
+    a_minzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
+    a_maxzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
+    a_rangeend = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
+    a_rangestart = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
+    a_labelminzoom = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
 }
 
 void SDFGlyphShader::bind(char *offset) {
     const int stride = 16;
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
-    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
-    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
-    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
-    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
-    CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14));
 }
 
 void SDFIconShader::bind(char *offset) {
     const int stride = 20;
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
-    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
-    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
-    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
-    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
-    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
-    CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
+    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    MBGL_CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
 }
diff --git a/src/mbgl/shader/shader.cpp b/src/mbgl/shader/shader.cpp
index 73270dbdde..c43863b52c 100644
--- a/src/mbgl/shader/shader.cpp
+++ b/src/mbgl/shader/shader.cpp
@@ -16,7 +16,7 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
       program(0) {
     util::stopwatch stopwatch("shader compilation", Event::Shader);
 
-    program = CHECK_ERROR(glCreateProgram());
+    program = MBGL_CHECK_ERROR(glCreateProgram());
 
     if (!mbgl::platform::defaultShaderCache().empty()) {
         binaryFileName = mbgl::platform::defaultShaderCache() + name + ".bin";
@@ -39,11 +39,11 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
                     bool binaryOk = fread(binary.get(), binaryLength, 1, binaryFile) == 1;
 
                     if (binaryOk) {
-                        CHECK_ERROR(gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength));
+                        MBGL_CHECK_ERROR(gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength));
 
                         // Check if the binary was valid
                         GLint status;
-                        CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
+                        MBGL_CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
                         if (status == GL_TRUE) {
                             skipCompile = true;
                         }
@@ -61,48 +61,48 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
     if (!skipCompile) {
         if (!compileShader(&vertShader, GL_VERTEX_SHADER, vertSource)) {
             Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertSource);
-            CHECK_ERROR(glDeleteProgram(program));
+            MBGL_CHECK_ERROR(glDeleteProgram(program));
             program = 0;
             return;
         }
 
         if (!compileShader(&fragShader, GL_FRAGMENT_SHADER, fragSource)) {
             Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragSource);
-            CHECK_ERROR(glDeleteShader(vertShader));
+            MBGL_CHECK_ERROR(glDeleteShader(vertShader));
             vertShader = 0;
-            CHECK_ERROR(glDeleteProgram(program));
+            MBGL_CHECK_ERROR(glDeleteProgram(program));
             program = 0;
             return;
         }
 
         // Attach shaders
-        CHECK_ERROR(glAttachShader(program, vertShader));
-        CHECK_ERROR(glAttachShader(program, fragShader));
+        MBGL_CHECK_ERROR(glAttachShader(program, vertShader));
+        MBGL_CHECK_ERROR(glAttachShader(program, fragShader));
 
         {
             if (!binaryFileName.empty() && (gl::ProgramParameteri != nullptr)) {
-                CHECK_ERROR(gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE));
+                MBGL_CHECK_ERROR(gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE));
             }
 
             // Link program
             GLint status;
-            CHECK_ERROR(glLinkProgram(program));
+            MBGL_CHECK_ERROR(glLinkProgram(program));
 
-            CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
+            MBGL_CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
             if (status == 0) {
                 GLint logLength;
-                CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
+                MBGL_CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
                 if (logLength > 0) {
                     std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-                    CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
+                    MBGL_CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
                     Log::Error(Event::Shader, "Program failed to link: %s", log.get());
                 }
 
-                CHECK_ERROR(glDeleteShader(vertShader));
+                MBGL_CHECK_ERROR(glDeleteShader(vertShader));
                 vertShader = 0;
-                CHECK_ERROR(glDeleteShader(fragShader));
+                MBGL_CHECK_ERROR(glDeleteShader(fragShader));
                 fragShader = 0;
-                CHECK_ERROR(glDeleteProgram(program));
+                MBGL_CHECK_ERROR(glDeleteProgram(program));
                 program = 0;
                 return;
             }
@@ -112,33 +112,33 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
     {
         // Validate program
         GLint status;
-        CHECK_ERROR(glValidateProgram(program));
+        MBGL_CHECK_ERROR(glValidateProgram(program));
 
-        CHECK_ERROR(glGetProgramiv(program, GL_VALIDATE_STATUS, &status));
+        MBGL_CHECK_ERROR(glGetProgramiv(program, GL_VALIDATE_STATUS, &status));
         if (status == 0) {
             GLint logLength;
-            CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
+            MBGL_CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
             if (logLength > 0) {
                 std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-                CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
+                MBGL_CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
                 Log::Error(Event::Shader, "Program failed to validate: %s", log.get());
             }
 
-            CHECK_ERROR(glDeleteShader(vertShader));
+            MBGL_CHECK_ERROR(glDeleteShader(vertShader));
             vertShader = 0;
-            CHECK_ERROR(glDeleteShader(fragShader));
+            MBGL_CHECK_ERROR(glDeleteShader(fragShader));
             fragShader = 0;
-            CHECK_ERROR(glDeleteProgram(program));
+            MBGL_CHECK_ERROR(glDeleteProgram(program));
             program = 0;
         }
     }
 
     if (!skipCompile) {
         // Remove the compiled shaders; they are now part of the program.
-        CHECK_ERROR(glDetachShader(program, vertShader));
-        CHECK_ERROR(glDeleteShader(vertShader));
-        CHECK_ERROR(glDetachShader(program, fragShader));
-        CHECK_ERROR(glDeleteShader(fragShader));
+        MBGL_CHECK_ERROR(glDetachShader(program, vertShader));
+        MBGL_CHECK_ERROR(glDeleteShader(vertShader));
+        MBGL_CHECK_ERROR(glDetachShader(program, fragShader));
+        MBGL_CHECK_ERROR(glDeleteShader(fragShader));
     }
 
     valid = true;
@@ -148,32 +148,32 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
 bool Shader::compileShader(GLuint *shader, GLenum type, const GLchar *source) {
     GLint status;
 
-    *shader = CHECK_ERROR(glCreateShader(type));
+    *shader = MBGL_CHECK_ERROR(glCreateShader(type));
     const GLchar *strings[] = { source };
     const GLsizei lengths[] = { (GLsizei)strlen(source) };
-    CHECK_ERROR(glShaderSource(*shader, 1, strings, lengths));
+    MBGL_CHECK_ERROR(glShaderSource(*shader, 1, strings, lengths));
 
-    CHECK_ERROR(glCompileShader(*shader));
+    MBGL_CHECK_ERROR(glCompileShader(*shader));
 
-    CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
+    MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
     if (status == 0) {
         GLint logLength;
-        CHECK_ERROR(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
+        MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
         if (logLength > 0) {
             std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-            CHECK_ERROR(glGetShaderInfoLog(*shader, logLength, &logLength, log.get()));
+            MBGL_CHECK_ERROR(glGetShaderInfoLog(*shader, logLength, &logLength, log.get()));
             Log::Error(Event::Shader, "Shader failed to compile: %s", log.get());
         }
 
-        CHECK_ERROR(glDeleteShader(*shader));
+        MBGL_CHECK_ERROR(glDeleteShader(*shader));
         *shader = 0;
         return false;
     }
 
-    CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
+    MBGL_CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
     if (status == GL_FALSE) {
     Log::Error(Event::Shader, "Shader %s failed to compile.", name, type);
-        CHECK_ERROR(glDeleteShader(*shader));
+        MBGL_CHECK_ERROR(glDeleteShader(*shader));
         *shader = 0;
         return false;
     }
@@ -186,11 +186,11 @@ Shader::~Shader() {
         // Retrieve the program binary
         GLsizei binaryLength;
         GLenum binaryFormat;
-        CHECK_ERROR(glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength));
+        MBGL_CHECK_ERROR(glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength));
         if (binaryLength > 0) {
             std::unique_ptr<char[]> binary = mbgl::util::make_unique<char[]>(binaryLength);
             if (binary != nullptr) {
-                CHECK_ERROR(gl::GetProgramBinary(program, binaryLength, NULL, &binaryFormat, binary.get()));
+                MBGL_CHECK_ERROR(gl::GetProgramBinary(program, binaryLength, NULL, &binaryFormat, binary.get()));
 
                 // Write the binary to a file
                 FILE *binaryFile = fopen(binaryFileName.c_str(), "wb");
@@ -206,7 +206,7 @@ Shader::~Shader() {
     }
 
     if (program) {
-        CHECK_ERROR(glDeleteProgram(program));
+        MBGL_CHECK_ERROR(glDeleteProgram(program));
         program = 0;
         valid = false;
     }
diff --git a/src/mbgl/shader/uniform.cpp b/src/mbgl/shader/uniform.cpp
index f2b03ac0b1..c013699bfd 100644
--- a/src/mbgl/shader/uniform.cpp
+++ b/src/mbgl/shader/uniform.cpp
@@ -4,42 +4,42 @@ namespace mbgl {
 
 template <>
 void Uniform<float>::bind(const float& t) {
-    CHECK_ERROR(glUniform1f(location, t));
+    MBGL_CHECK_ERROR(glUniform1f(location, t));
 }
 
 template <>
 void Uniform<int32_t>::bind(const int32_t& t) {
-    CHECK_ERROR(glUniform1i(location, t));
+    MBGL_CHECK_ERROR(glUniform1i(location, t));
 }
 
 template <>
 void Uniform<std::array<float, 2>>::bind(const std::array<float, 2>& t) {
-    CHECK_ERROR(glUniform2fv(location, 1, t.data()));
+    MBGL_CHECK_ERROR(glUniform2fv(location, 1, t.data()));
 }
 
 template <>
 void Uniform<std::array<float, 3>>::bind(const std::array<float, 3>& t) {
-    CHECK_ERROR(glUniform3fv(location, 1, t.data()));
+    MBGL_CHECK_ERROR(glUniform3fv(location, 1, t.data()));
 }
 
 template <>
 void Uniform<std::array<float, 4>>::bind(const std::array<float, 4>& t) {
-    CHECK_ERROR(glUniform4fv(location, 1, t.data()));
+    MBGL_CHECK_ERROR(glUniform4fv(location, 1, t.data()));
 }
 
 template <>
 void UniformMatrix<2>::bind(const std::array<float, 4>& t) {
-    CHECK_ERROR(glUniformMatrix2fv(location, 1, GL_FALSE, t.data()));
+    MBGL_CHECK_ERROR(glUniformMatrix2fv(location, 1, GL_FALSE, t.data()));
 }
 
 template <>
 void UniformMatrix<3>::bind(const std::array<float, 9>& t) {
-    CHECK_ERROR(glUniformMatrix3fv(location, 1, GL_FALSE, t.data()));
+    MBGL_CHECK_ERROR(glUniformMatrix3fv(location, 1, GL_FALSE, t.data()));
 }
 
 template <>
 void UniformMatrix<4>::bind(const std::array<float, 16>& t) {
-    CHECK_ERROR(glUniformMatrix4fv(location, 1, GL_FALSE, t.data()));
+    MBGL_CHECK_ERROR(glUniformMatrix4fv(location, 1, GL_FALSE, t.data()));
 }
 
 // Add more as needed.
diff --git a/src/mbgl/shader/uniform.hpp b/src/mbgl/shader/uniform.hpp
index 9d0b9e24b9..9a25d105cf 100644
--- a/src/mbgl/shader/uniform.hpp
+++ b/src/mbgl/shader/uniform.hpp
@@ -10,7 +10,7 @@ template <typename T>
 class Uniform {
 public:
     Uniform(const GLchar* name, const Shader& shader) {
-         location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
+         location = MBGL_CHECK_ERROR(glGetUniformLocation(shader.program, name));
     }
 
     void operator=(const T& t) {
@@ -33,7 +33,7 @@ public:
     typedef std::array<float, C*R> T;
 
     UniformMatrix(const GLchar* name, const Shader& shader) {
-        location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
+        location = MBGL_CHECK_ERROR(glGetUniformLocation(shader.program, name));
     }
 
     void operator=(const T& t) {