Use CHECK_ERROR on every GL call

36 files changed, 365 insertions, 355 deletions

diff --git a/platform/default/glfw_view.cpp b/platform/default/glfw_view.cpp
index 7cfb132133..701ce2023d 100644
--- a/platform/default/glfw_view.cpp
+++ b/platform/default/glfw_view.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/platform/default/glfw_view.hpp>
 #include <mbgl/platform/gl.hpp>
+#include <mbgl/platform/log.hpp>
 
 GLFWView::GLFWView(bool fullscreen_) : fullscreen(fullscreen_) {
 #ifdef NVIDIA
@@ -11,9 +12,16 @@ GLFWView::~GLFWView() {
     glfwTerminate();
 }
 
+void glfwError(int error, const char *description) {
+    mbgl::Log::Error(mbgl::Event::OpenGL, "GLFW error (%i): %s", error, description);
+    assert(false);
+}
+
 void GLFWView::initialize(mbgl::Map *map_) {
     View::initialize(map_);
 
+    glfwSetErrorCallback(glfwError);
+
     if (!glfwInit()) {
         fprintf(stderr, "Failed to initialize glfw\n");
         exit(1);
@@ -65,7 +73,7 @@ void GLFWView::initialize(mbgl::Map *map_) {
     glfwSetScrollCallback(window, scroll);
     glfwSetKeyCallback(window, key);
 
-    const std::string extensions = (char *)glGetString(GL_EXTENSIONS);
+    const std::string extensions = (char *)CHECK_ERROR(glGetString(GL_EXTENSIONS));
     {
         using namespace mbgl;
 
@@ -345,9 +353,9 @@ void show_debug_image(std::string name, const char *data, size_t width, size_t h
     glfwGetFramebufferSize(debug_window, &fb_width, &fb_height);
     float scale = (float)fb_width / (float)width;
 
-    glPixelZoom(scale, -scale);
-    glRasterPos2f(-1.0f, 1.0f);
-    glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
+    CHECK_ERROR(glPixelZoom(scale, -scale));
+    CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
+    CHECK_ERROR(glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data));
     glfwSwapBuffers(debug_window);
 
     glfwMakeContextCurrent(current_window);
@@ -377,13 +385,13 @@ void show_color_debug_image(std::string name, const char *data, size_t logical_w
     float x_scale = (float)fb_width / (float)width;
     float y_scale = (float)fb_height / (float)height;
 
-    glClear(GL_COLOR_BUFFER_BIT);
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
+    CHECK_ERROR(glEnable(GL_BLEND));
+    CHECK_ERROR(glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
-    glPixelZoom(x_scale, -y_scale);
-    glRasterPos2f(-1.0f, 1.0f);
-    glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
+    CHECK_ERROR(glPixelZoom(x_scale, -y_scale));
+    CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
+    CHECK_ERROR(glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data));
     glfwSwapBuffers(debug_window);
 
     glfwMakeContextCurrent(current_window);
diff --git a/platform/default/headless_view.cpp b/platform/default/headless_view.cpp
index d414c3f450..e3273a0972 100644
--- a/platform/default/headless_view.cpp
+++ b/platform/default/headless_view.cpp
@@ -52,7 +52,7 @@ HeadlessView::HeadlessView(std::shared_ptr<HeadlessDisplay> display)
 
 void HeadlessView::loadExtensions() {
     make_active();
-    const std::string extensions = (char *)glGetString(GL_EXTENSIONS);
+    const std::string extensions = (char *)CHECK_ERROR(glGetString(GL_EXTENSIONS));
 
 #ifdef MBGL_USE_CGL
     if (extensions.find("GL_APPLE_vertex_array_object") != std::string::npos) {
@@ -204,23 +204,23 @@ void HeadlessView::resize(uint16_t width, uint16_t height, float pixelRatio) {
     make_active();
 
     // Create depth/stencil buffer
-    glGenRenderbuffersEXT(1, &fboDepthStencil);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil);
-    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+    CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil));
+    CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil));
+    CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h));
+    CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
 
-    glGenRenderbuffersEXT(1, &fboColor);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor);
-    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h);
-    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+    CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor));
+    CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor));
+    CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h));
+    CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
 
-    glGenFramebuffersEXT(1, &fbo);
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+    CHECK_ERROR(glGenFramebuffersEXT(1, &fbo));
+    CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo));
 
-    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor);
-    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil);
+    CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor));
+    CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil));
 
-    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+    GLenum status = CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
 
     if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
         std::stringstream error("Couldn't create framebuffer: ");
@@ -247,7 +247,7 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
     auto pixels = util::make_unique<uint32_t[]>(w * h);
 
     make_active();
-    glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
+    CHECK_ERROR(glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get()));
     make_inactive();
 
     const int stride = w * 4;
@@ -265,20 +265,20 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
 void HeadlessView::clear_buffers() {
     make_active();
 
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
 
     if (fbo) {
-        glDeleteFramebuffersEXT(1, &fbo);
+        CHECK_ERROR(glDeleteFramebuffersEXT(1, &fbo));
         fbo = 0;
     }
 
     if (fboColor) {
-        glDeleteTextures(1, &fboColor);
+        CHECK_ERROR(glDeleteTextures(1, &fboColor));
         fboColor = 0;
     }
 
     if (fboDepthStencil) {
-        glDeleteRenderbuffersEXT(1, &fboDepthStencil);
+        CHECK_ERROR(glDeleteRenderbuffersEXT(1, &fboDepthStencil));
         fboDepthStencil = 0;
     }
 
diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp
index 80cc6b9d1a..b587de3c7c 100644
--- a/src/mbgl/geometry/buffer.hpp
+++ b/src/mbgl/geometry/buffer.hpp
@@ -21,7 +21,7 @@ public:
     ~Buffer() {
         cleanup();
         if (buffer != 0) {
-            glDeleteBuffers(1, &buffer);
+            CHECK_ERROR(glDeleteBuffers(1, &buffer));
             buffer = 0;
         }
     }
@@ -39,16 +39,16 @@ public:
     // Transfers this buffer to the GPU and binds the buffer to the GL context.
     void bind(bool force = false) {
         if (buffer == 0) {
-            glGenBuffers(1, &buffer);
+            CHECK_ERROR(glGenBuffers(1, &buffer));
             force = true;
         }
-        glBindBuffer(bufferType, buffer);
+        CHECK_ERROR(glBindBuffer(bufferType, buffer));
         if (force) {
             if (array == nullptr) {
                 throw std::runtime_error("Buffer was already deleted or doesn't contain elements");
             }
 
-            glBufferData(bufferType, pos, array, GL_STATIC_DRAW);
+            CHECK_ERROR(glBufferData(bufferType, pos, array, GL_STATIC_DRAW));
             if (!retainAfterUpload) {
                 cleanup();
             }
diff --git a/src/mbgl/geometry/glyph_atlas.cpp b/src/mbgl/geometry/glyph_atlas.cpp
index bafcf2b000..972cf69694 100644
--- a/src/mbgl/geometry/glyph_atlas.cpp
+++ b/src/mbgl/geometry/glyph_atlas.cpp
@@ -142,22 +142,22 @@ void GlyphAtlas::removeGlyphs(uint64_t tile_id) {
 
 void GlyphAtlas::bind() {
     if (!texture) {
-        glGenTextures(1, &texture);
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glGenTextures(1, &texture));
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
 #ifndef GL_ES_VERSION_2_0
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
 #endif
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     } else {
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
     }
 
     if (dirty) {
         std::lock_guard<std::mutex> lock(mtx);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get());
+        CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get()));
         dirty = false;
 
 #if defined(DEBUG)
diff --git a/src/mbgl/geometry/sprite_atlas.cpp b/src/mbgl/geometry/sprite_atlas.cpp
index 7dc8f60ae6..8748519e3a 100644
--- a/src/mbgl/geometry/sprite_atlas.cpp
+++ b/src/mbgl/geometry/sprite_atlas.cpp
@@ -199,22 +199,22 @@ void SpriteAtlas::setSprite(util::ptr<Sprite> sprite_) {
 void SpriteAtlas::bind(bool linear) {
     bool first = false;
     if (!texture) {
-        glGenTextures(1, &texture);
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glGenTextures(1, &texture));
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
 #ifndef GL_ES_VERSION_2_0
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
 #endif
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
         first = true;
     } else {
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
     }
 
     GLuint filter_val = linear ? GL_LINEAR : GL_NEAREST;
     if (filter_val != filter) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_val);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter_val);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_val));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter_val));
         filter = filter_val;
     }
 
@@ -255,7 +255,7 @@ void SpriteAtlas::bind(bool linear) {
 SpriteAtlas::~SpriteAtlas() {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
-    glDeleteTextures(1, &texture);
+    CHECK_ERROR(glDeleteTextures(1, &texture));
     texture = 0;
     ::operator delete(data), data = nullptr;
 }
diff --git a/src/mbgl/geometry/vao.cpp b/src/mbgl/geometry/vao.cpp
index 66822ba5ce..47f894fd1e 100644
--- a/src/mbgl/geometry/vao.cpp
+++ b/src/mbgl/geometry/vao.cpp
@@ -8,7 +8,7 @@ VertexArrayObject::~VertexArrayObject() {
     if (!gl::DeleteVertexArrays) return;
 
     if (vao) {
-        gl::DeleteVertexArrays(1, &vao);
+        CHECK_ERROR(gl::DeleteVertexArrays(1, &vao));
     }
 }
 
@@ -23,9 +23,9 @@ void VertexArrayObject::bindVertexArrayObject() {
     }
 
     if (!vao) {
-        gl::GenVertexArrays(1, &vao);
+        CHECK_ERROR(gl::GenVertexArrays(1, &vao));
     }
-    gl::BindVertexArray(vao);
+    CHECK_ERROR(gl::BindVertexArray(vao));
 }
 
 void VertexArrayObject::verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer,
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index f089374564..bb25af9705 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -23,10 +23,10 @@ bool DebugBucket::hasData() const {
 
 void DebugBucket::drawLines(PlainShader& shader) {
     array.bind(shader, fontBuffer, BUFFER_OFFSET(0));
-    glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index()));
+    CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index())));
 }
 
 void DebugBucket::drawPoints(PlainShader& shader) {
     array.bind(shader, fontBuffer, BUFFER_OFFSET(0));
-    glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index()));
+    CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index())));
 }
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index 0a7d77935d..2eeb86d4e2 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -217,7 +217,7 @@ void FillBucket::drawElements(PlainShader& shader) {
     char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
         group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
@@ -228,7 +228,7 @@ void FillBucket::drawElements(PatternShader& shader) {
     char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
         group.array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
@@ -239,7 +239,7 @@ void FillBucket::drawVertices(OutlineShader& shader) {
     char *elements_index = BUFFER_OFFSET(line_elements_start * lineElementsBuffer.itemSize);
     for (line_group_type& group : lineGroups) {
         group.array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index);
-        glDrawElements(GL_LINES, group.elements_length * 2, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_LINES, group.elements_length * 2, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * lineElementsBuffer.itemSize;
     }
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 8267cbaba2..8c84b37873 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -368,7 +368,7 @@ void LineBucket::drawLines(LineShader& shader) {
             continue;
         }
         group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
@@ -382,7 +382,7 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader) {
             continue;
         }
         group.array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
@@ -396,7 +396,7 @@ void LineBucket::drawPoints(LinejoinShader& shader) {
             continue;
         }
         group.array[0].bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
-        glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * vertexBuffer.itemSize;
         elements_index += group.elements_length * pointElementsBuffer.itemSize;
     }
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index c0c1fe2489..b350eba55a 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -45,13 +45,13 @@ void Painter::setup() {
     // Enable GL debugging
     if ((gl::DebugMessageControl != nullptr) && (gl::DebugMessageCallback != nullptr)) {
         // This will enable all messages including performance hints
-        gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
+        CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE));
 
         // This will only enable high and medium severity messages
         //gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE);
         //gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE);
 
-        gl::DebugMessageCallback(gl::debug_callback, nullptr);
+        CHECK_ERROR(gl::DebugMessageCallback(gl::debug_callback, nullptr));
     }
 
     setupShaders();
@@ -74,17 +74,17 @@ void Painter::setup() {
     // We are blending new pixels on top of old pixels. Since we have depth testing
     // and are drawing opaque fragments first front-to-back, then translucent
     // fragments back-to-front, this shades the fewest fragments possible.
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    CHECK_ERROR(glEnable(GL_BLEND));
+    CHECK_ERROR(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
     // Set clear values
-    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-    glClearDepth(1.0f);
-    glClearStencil(0x0);
+    CHECK_ERROR(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
+    CHECK_ERROR(glClearDepth(1.0f));
+    CHECK_ERROR(glClearStencil(0x0));
 
     // Stencil test
-    glEnable(GL_STENCIL_TEST);
-    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    CHECK_ERROR(glEnable(GL_STENCIL_TEST));
+    CHECK_ERROR(glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE));
 }
 
 void Painter::setupShaders() {
@@ -125,7 +125,7 @@ void Painter::resize() {
     if (gl_viewport != state.getFramebufferDimensions()) {
         gl_viewport = state.getFramebufferDimensions();
         assert(gl_viewport[0] > 0 && gl_viewport[1] > 0);
-        glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
+        CHECK_ERROR(glViewport(0, 0, gl_viewport[0], gl_viewport[1]));
     }
 }
 
@@ -135,28 +135,28 @@ void Painter::setDebug(bool enabled) {
 
 void Painter::useProgram(uint32_t program) {
     if (gl_program != program) {
-        glUseProgram(program);
+        CHECK_ERROR(glUseProgram(program));
         gl_program = program;
     }
 }
 
 void Painter::lineWidth(float line_width) {
     if (gl_lineWidth != line_width) {
-        glLineWidth(line_width);
+        CHECK_ERROR(glLineWidth(line_width));
         gl_lineWidth = line_width;
     }
 }
 
 void Painter::depthMask(bool value) {
     if (gl_depthMask != value) {
-        glDepthMask(value ? GL_TRUE : GL_FALSE);
+        CHECK_ERROR(glDepthMask(value ? GL_TRUE : GL_FALSE));
         gl_depthMask = value;
     }
 }
 
 void Painter::depthRange(const float near, const float far) {
     if (gl_depthRange[0] != near || gl_depthRange[1] != far) {
-        glDepthRange(near, far);
+        CHECK_ERROR(glDepthRange(near, far));
         gl_depthRange = {{ near, far }};
     }
 }
@@ -179,17 +179,17 @@ void Painter::changeMatrix() {
 
 void Painter::clear() {
     gl::group group("clear");
-    glStencilMask(0xFF);
+    CHECK_ERROR(glStencilMask(0xFF));
     depthMask(true);
 
-    glClearColor(0, 0, 0, 0);
-    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    CHECK_ERROR(glClearColor(0, 0, 0, 0));
+    CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
 }
 
 void Painter::setOpaque() {
     if (pass != RenderPass::Opaque) {
         pass = RenderPass::Opaque;
-        glDisable(GL_BLEND);
+        CHECK_ERROR(glDisable(GL_BLEND));
         depthMask(true);
     }
 }
@@ -197,7 +197,7 @@ void Painter::setOpaque() {
 void Painter::setTranslucent() {
     if (pass != RenderPass::Translucent) {
         pass = RenderPass::Translucent;
-        glEnable(GL_BLEND);
+        CHECK_ERROR(glEnable(GL_BLEND));
         depthMask(false);
     }
 }
@@ -209,7 +209,7 @@ void Painter::setStrata(float value) {
 void Painter::prepareTile(const Tile& tile) {
     const GLint ref = (GLint)tile.clip.reference.to_ulong();
     const GLuint mask = (GLuint)tile.clip.mask.to_ulong();
-    glStencilFunc(GL_EQUAL, ref, mask);
+    CHECK_ERROR(glStencilFunc(GL_EQUAL, ref, mask));
 }
 
 void Painter::render(const Style& style, const std::set<util::ptr<StyleSource>>& sources,
@@ -244,7 +244,7 @@ void Painter::render(const Style& style, const std::set<util::ptr<StyleSource>>&
         source->source->finishRender(*this);
     }
 
-    glFlush();
+    CHECK_ERROR(glFlush());
 }
 
 void Painter::renderLayers(util::ptr<StyleLayerGroup> group) {
@@ -427,10 +427,10 @@ void Painter::renderBackground(util::ptr<StyleLayer> layer_desc) {
         backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0));
     }
 
-    glDisable(GL_STENCIL_TEST);
+    CHECK_ERROR(glDisable(GL_STENCIL_TEST));
     depthRange(strata + strata_epsilon, 1.0f);
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    glEnable(GL_STENCIL_TEST);
+    CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
+    CHECK_ERROR(glEnable(GL_STENCIL_TEST));
 }
 
 mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor) {
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index dc625ded4e..00f567eaf7 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -10,9 +10,9 @@ void Painter::drawClippingMasks(const std::set<util::ptr<StyleSource>> &sources)
     gl::group group("clipping masks");
 
     useProgram(plainShader->program);
-    glDisable(GL_DEPTH_TEST);
+    CHECK_ERROR(glDisable(GL_DEPTH_TEST));
     depthMask(false);
-    glColorMask(false, false, false, false);
+    CHECK_ERROR(glColorMask(false, false, false, false));
     depthRange(1.0f, 1.0f);
 
     coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0));
@@ -21,10 +21,10 @@ void Painter::drawClippingMasks(const std::set<util::ptr<StyleSource>> &sources)
         source->source->drawClippingMasks(*this);
     }
 
-    glEnable(GL_DEPTH_TEST);
-    glColorMask(true, true, true, true);
+    CHECK_ERROR(glEnable(GL_DEPTH_TEST));
+    CHECK_ERROR(glColorMask(true, true, true, true));
     depthMask(true);
-    glStencilMask(0x0);
+    CHECK_ERROR(glStencilMask(0x0));
 }
 
 void Painter::drawClippingMask(const mat4& matrix, const ClipID &clip) {
@@ -32,8 +32,8 @@ void Painter::drawClippingMask(const mat4& matrix, const ClipID &clip) {
 
     const GLint ref = (GLint)(clip.reference.to_ulong());
     const GLuint mask = (GLuint)(clip.mask.to_ulong());
-    glStencilFunc(GL_ALWAYS, ref, mask);
-    glStencilMask(mask);
+    CHECK_ERROR(glStencilFunc(GL_ALWAYS, ref, mask));
+    CHECK_ERROR(glStencilMask(mask));
 
-    glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
+    CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index()));
 }
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index c4d273aa47..62017e7653 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -18,7 +18,7 @@ void Painter::renderTileDebug(const Tile& tile) {
 void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
     gl::group group("debug text");
 
-    glDisable(GL_DEPTH_TEST);
+    CHECK_ERROR(glDisable(GL_DEPTH_TEST));
 
     useProgram(plainShader->program);
     plainShader->u_matrix = matrix;
@@ -30,7 +30,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
 
 #ifndef GL_ES_VERSION_2_0
     // Draw line "end caps"
-    glPointSize(2);
+    CHECK_ERROR(glPointSize(2));
     bucket.drawPoints(*plainShader);
 #endif
 
@@ -39,7 +39,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
     lineWidth(2.0f * state.getPixelRatio());
     bucket.drawLines(*plainShader);
 
-    glEnable(GL_DEPTH_TEST);
+    CHECK_ERROR(glEnable(GL_DEPTH_TEST));
 }
 
 void Painter::renderDebugFrame(const mat4 &matrix) {
@@ -48,7 +48,7 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
     // Disable depth test and don't count this towards the depth buffer,
     // but *don't* disable stencil test, as we want to clip the red tile border
     // to the tile viewport.
-    glDisable(GL_DEPTH_TEST);
+    CHECK_ERROR(glDisable(GL_DEPTH_TEST));
 
     useProgram(plainShader->program);
     plainShader->u_matrix = matrix;
@@ -57,9 +57,9 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
     tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET(0));
     plainShader->u_color = {{ 1.0f, 0.0f, 0.0f, 1.0f }};
     lineWidth(4.0f * state.getPixelRatio());
-    glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index());
+    CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index()));
 
-    glEnable(GL_DEPTH_TEST);
+    CHECK_ERROR(glEnable(GL_DEPTH_TEST));
 }
 
 void Painter::renderDebugText(const std::vector<std::string> &strings) {
@@ -69,8 +69,8 @@ void Painter::renderDebugText(const std::vector<std::string> &strings) {
 
     gl::group group("debug text");
 
-    glDisable(GL_DEPTH_TEST);
-    glStencilFunc(GL_ALWAYS, 0xFF, 0xFF);
+    CHECK_ERROR(glDisable(GL_DEPTH_TEST));
+    CHECK_ERROR(glStencilFunc(GL_ALWAYS, 0xFF, 0xFF));
 
     useProgram(plainShader->program);
     plainShader->u_matrix = nativeMatrix;
@@ -88,15 +88,15 @@ void Painter::renderDebugText(const std::vector<std::string> &strings) {
         debugFontArray.bind(*plainShader, debugFontBuffer, BUFFER_OFFSET(0));
         plainShader->u_color = {{ 1.0f, 1.0f, 1.0f, 1.0f }};
         lineWidth(4.0f * state.getPixelRatio());
-        glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index());
+        CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index()));
     #ifndef GL_ES_VERSION_2_0
-        glPointSize(2);
-        glDrawArrays(GL_POINTS, 0, (GLsizei)debugFontBuffer.index());
+        CHECK_ERROR(glPointSize(2));
+        CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)debugFontBuffer.index()));
     #endif
         plainShader->u_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
         lineWidth(2.0f * state.getPixelRatio());
-        glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index());
+        CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index()));
     }
 
-    glEnable(GL_DEPTH_TEST);
+    CHECK_ERROR(glEnable(GL_DEPTH_TEST));
 }
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index f2759ffd61..a4e99b55e1 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -76,7 +76,7 @@ void Painter::renderFill(FillBucket& bucket, util::ptr<StyleLayer> layer_desc, c
             patternShader->u_mix = mix;
             patternShader->u_patternmatrix = patternMatrix;
 
-            glActiveTexture(GL_TEXTURE0);
+            CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
             spriteAtlas.bind(true);
 
             // Draw the actual triangles into the color & stencil buffer.
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index 4bf50569ac..75270bb5af 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -55,7 +55,7 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
 #if defined(GL_ES_VERSION_2_0)
         linejoinShader->u_size = pointSize;
 #else
-        glPointSize(pointSize);
+        CHECK_ERROR(glPointSize(pointSize));
 #endif
         bucket.drawPoints(*linejoinShader);
     }
@@ -80,7 +80,7 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
         linepatternShader->u_fade = fade;
 
         spriteAtlas.bind(true);
-        glDepthRange(strata + strata_epsilon, 1.0f);  // may or may not matter
+        CHECK_ERROR(glDepthRange(strata + strata_epsilon, 1.0f));  // may or may not matter
 
         bucket.drawLinePatterns(*linepatternShader);
 
diff --git a/src/mbgl/renderer/painter_prerender.cpp b/src/mbgl/renderer/painter_prerender.cpp
index f38470530b..1104de6e13 100644
--- a/src/mbgl/renderer/painter_prerender.cpp
+++ b/src/mbgl/renderer/painter_prerender.cpp
@@ -6,18 +6,18 @@
 using namespace mbgl;
 
 void Painter::preparePrerender(RasterBucket &bucket) {
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_STENCIL_TEST);
+    CHECK_ERROR(glDisable(GL_DEPTH_TEST));
+    CHECK_ERROR(glDisable(GL_STENCIL_TEST));
 
 // Render the actual tile.
 #if GL_EXT_discard_framebuffer
     const GLenum discards[] = {GL_COLOR_ATTACHMENT0};
-    glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
+    CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
 #endif
-    glClearColor(0.0, 0.0, 0.0, 0.0);
-    glClear(GL_COLOR_BUFFER_BIT);
+    CHECK_ERROR(glClearColor(0.0, 0.0, 0.0, 0.0));
+    CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
 
-    glViewport(0, 0, bucket.properties.size, bucket.properties.size);
+    CHECK_ERROR(glViewport(0, 0, bucket.properties.size, bucket.properties.size));
 }
 
 void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix, const RasterProperties& properties) {
@@ -30,7 +30,7 @@ void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix,
 
     depthRange(strata, 1.0f);
 
-    glActiveTexture(GL_TEXTURE0);
+    CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
     rasterShader->u_image = 0;
     rasterShader->u_buffer = buffer;
     rasterShader->u_opacity = properties.opacity;
@@ -41,5 +41,5 @@ void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix,
     rasterShader->u_spin_weights = spinWeights(properties.hue_rotate);
     bucket.texture.bindTexture();
     coveringRasterArray.bind(*rasterShader, tileStencilBuffer, BUFFER_OFFSET(0));
-    glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
+    CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index()));
 }
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index df655cdae8..6e02e159a9 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -44,10 +44,10 @@ void Painter::renderRaster(RasterBucket& bucket, util::ptr<StyleLayer> layer_des
 
             bucket.texture.unbindFramebuffer();
 
-            glEnable(GL_DEPTH_TEST);
-            glEnable(GL_STENCIL_TEST);
+            CHECK_ERROR(glEnable(GL_DEPTH_TEST));
+            CHECK_ERROR(glEnable(GL_STENCIL_TEST));
 
-            glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
+            CHECK_ERROR(glViewport(0, 0, gl_viewport[0], gl_viewport[1]));
 
         }
 
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index 79625f1681..b2f2e6df61 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -118,7 +118,7 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
 
     const SymbolProperties &properties = layer_desc->getProperties<SymbolProperties>();
 
-    glDisable(GL_STENCIL_TEST);
+    CHECK_ERROR(glDisable(GL_STENCIL_TEST));
 
     if (bucket.hasIconData()) {
         bool sdf = bucket.sdfIcons;
@@ -204,5 +204,5 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
                   &SymbolBucket::drawGlyphs);
     }
 
-    glEnable(GL_STENCIL_TEST);
+    CHECK_ERROR(glEnable(GL_STENCIL_TEST));
 }
diff --git a/src/mbgl/renderer/prerendered_texture.cpp b/src/mbgl/renderer/prerendered_texture.cpp
index dd35f11372..08ed088f7d 100644
--- a/src/mbgl/renderer/prerendered_texture.cpp
+++ b/src/mbgl/renderer/prerendered_texture.cpp
@@ -11,12 +11,12 @@ PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties_)
 
 PrerenderedTexture::~PrerenderedTexture() {
     if (texture != 0) {
-        glDeleteTextures(1, &texture);
+        CHECK_ERROR(glDeleteTextures(1, &texture));
         texture = 0;
     }
 
     if (fbo != 0) {
-        glDeleteFramebuffers(1, &fbo);
+        CHECK_ERROR(glDeleteFramebuffers(1, &fbo));
         fbo = 0;
     }
 }
@@ -28,50 +28,50 @@ void PrerenderedTexture::bindTexture() {
         unbindFramebuffer();
     }
 
-    glBindTexture(GL_TEXTURE_2D, texture);
+    CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
 }
 
 void PrerenderedTexture::bindFramebuffer() {
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_fbo);
+    CHECK_ERROR(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_fbo));
 
     if (texture == 0) {
-        glGenTextures(1, &texture);
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glGenTextures(1, &texture));
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
 #ifndef GL_ES_VERSION_2_0
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
 #endif
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-        glBindTexture(GL_TEXTURE_2D, 0);
+        CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+        CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+        CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0));
     }
 
     if (fbo_depth_stencil == 0) {
         // Create depth/stencil buffer
-        glGenRenderbuffers(1, &fbo_depth_stencil);
-        glBindRenderbuffer(GL_RENDERBUFFER, fbo_depth_stencil);
+        CHECK_ERROR(glGenRenderbuffers(1, &fbo_depth_stencil));
+        CHECK_ERROR(glBindRenderbuffer(GL_RENDERBUFFER, fbo_depth_stencil));
 #ifdef GL_ES_VERSION_2_0
-        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, properties.size, properties.size);
+        CHECK_ERROR(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, properties.size, properties.size));
 #else
-        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, properties.size, properties.size);
+        CHECK_ERROR(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, properties.size, properties.size));
 #endif
-        glBindRenderbuffer(GL_RENDERBUFFER, 0);
+        CHECK_ERROR(glBindRenderbuffer(GL_RENDERBUFFER, 0));
     }
 
     if (fbo == 0) {
-        glGenFramebuffers(1, &fbo);
-        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
+        CHECK_ERROR(glGenFramebuffers(1, &fbo));
+        CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, fbo));
+        CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0));
 #ifdef GL_ES_VERSION_2_0
-        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
-        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
+        CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
+        CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
 #else
-        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
+        CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
 #endif
 
-        GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+        GLenum status = CHECK_ERROR(glCheckFramebufferStatus(GL_FRAMEBUFFER));
         if (status != GL_FRAMEBUFFER_COMPLETE) {
             fprintf(stderr, "Couldn't create framebuffer: ");
             switch (status) {
@@ -88,15 +88,15 @@ void PrerenderedTexture::bindFramebuffer() {
             return;
         }
     } else {
-        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+        CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, fbo));
     }
 }
 
 void PrerenderedTexture::unbindFramebuffer() {
-    glBindFramebuffer(GL_FRAMEBUFFER, previous_fbo);
+    CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, previous_fbo));
 
     if (fbo != 0) {
-        glDeleteFramebuffers(1, &fbo);
+        CHECK_ERROR(glDeleteFramebuffers(1, &fbo));
         fbo = 0;
     }
 }
@@ -106,49 +106,49 @@ void PrerenderedTexture::blur(Painter& painter, uint16_t passes) {
 
     // Create a secondary texture
     GLuint secondary_texture;
-    glGenTextures(1, &secondary_texture);
-    glBindTexture(GL_TEXTURE_2D, secondary_texture);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-    glBindTexture(GL_TEXTURE_2D, 0);
+    CHECK_ERROR(glGenTextures(1, &secondary_texture));
+    CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, secondary_texture));
+    CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+    CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+    CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+    CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+    CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
+    CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0));
 
 
     painter.useProgram(painter.gaussianShader->program);
     painter.gaussianShader->u_matrix = painter.flipMatrix;
     painter.gaussianShader->u_image = 0;
-    glActiveTexture(GL_TEXTURE0);
+    CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
 
     for (int i = 0; i < passes; i++) {
         // Render horizontal
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, secondary_texture, 0);
+        CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, secondary_texture, 0));
 #if GL_EXT_discard_framebuffer
         const GLenum discards[] = { GL_COLOR_ATTACHMENT0 };
-        glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
+        CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
 #endif
-        glClear(GL_COLOR_BUFFER_BIT);
+        CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
 
         painter.gaussianShader->u_offset = {{ 1.0f / float(properties.size), 0 }};
-        glBindTexture(GL_TEXTURE_2D, original_texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, original_texture));
         painter.coveringGaussianArray.bind(*painter.gaussianShader, painter.tileStencilBuffer, BUFFER_OFFSET(0));
-        glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index());
+        CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index()));
 
 
 
         // Render vertical
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, original_texture, 0);
+        CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, original_texture, 0));
 #if GL_EXT_discard_framebuffer
-        glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
+        CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
 #endif
-        glClear(GL_COLOR_BUFFER_BIT);
+        CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
 
         painter.gaussianShader->u_offset = {{ 0, 1.0f / float(properties.size) }};
-        glBindTexture(GL_TEXTURE_2D, secondary_texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, secondary_texture));
         painter.coveringGaussianArray.bind(*painter.gaussianShader, painter.tileStencilBuffer, BUFFER_OFFSET(0));
-        glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index());
+        CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index()));
     }
 
-    glDeleteTextures(1, &secondary_texture);
+    CHECK_ERROR(glDeleteTextures(1, &secondary_texture));
 }
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index 85bb66970e..c1e3490f8b 100644
--- a/src/mbgl/renderer/raster_bucket.cpp
+++ b/src/mbgl/renderer/raster_bucket.cpp
@@ -21,14 +21,14 @@ void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices
     raster.bind(true);
     shader.u_image = 0;
     array.bind(shader, vertices, BUFFER_OFFSET(0));
-    glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
+    CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index()));
 }
 
 void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture_) {
     raster.bind(texture_);
     shader.u_image = 0;
     array.bind(shader, vertices, BUFFER_OFFSET(0));
-    glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
+    CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index()));
 }
 
 bool RasterBucket::hasData() const {
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index a005449628..8e58313ad4 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -397,7 +397,7 @@ void SymbolBucket::drawGlyphs(SDFShader &shader) {
     char *elements_index = BUFFER_OFFSET(0);
     for (TextElementGroup &group : text.groups) {
         group.array[0].bind(shader, text.vertices, text.triangles, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * text.vertices.itemSize;
         elements_index += group.elements_length * text.triangles.itemSize;
     }
@@ -408,7 +408,7 @@ void SymbolBucket::drawIcons(SDFShader &shader) {
     char *elements_index = BUFFER_OFFSET(0);
     for (IconElementGroup &group : icon.groups) {
         group.array[0].bind(shader, icon.vertices, icon.triangles, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * icon.vertices.itemSize;
         elements_index += group.elements_length * icon.triangles.itemSize;
     }
@@ -419,7 +419,7 @@ void SymbolBucket::drawIcons(IconShader &shader) {
     char *elements_index = BUFFER_OFFSET(0);
     for (IconElementGroup &group : icon.groups) {
         group.array[1].bind(shader, icon.vertices, icon.triangles, vertex_index);
-        glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
+        CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group.vertex_length * icon.vertices.itemSize;
         elements_index += group.elements_length * icon.triangles.itemSize;
     }
diff --git a/src/mbgl/shader/dot_shader.cpp b/src/mbgl/shader/dot_shader.cpp
index a897f410a7..9874f15efa 100644
--- a/src/mbgl/shader/dot_shader.cpp
+++ b/src/mbgl/shader/dot_shader.cpp
@@ -17,10 +17,10 @@ DotShader::DotShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void DotShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 9060f0ee71..9569d4047f 100644
--- a/src/mbgl/shader/gaussian_shader.cpp
+++ b/src/mbgl/shader/gaussian_shader.cpp
@@ -19,10 +19,10 @@ GaussianShader::GaussianShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void GaussianShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 5c54177eb6..a50c525b6e 100644
--- a/src/mbgl/shader/icon_shader.cpp
+++ b/src/mbgl/shader/icon_shader.cpp
@@ -17,44 +17,44 @@ IconShader::IconShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
-    a_offset = glGetAttribLocation(program, "a_offset");
-    a_tex = glGetAttribLocation(program, "a_tex");
-    a_angle = glGetAttribLocation(program, "a_angle");
-    a_minzoom = glGetAttribLocation(program, "a_minzoom");
-    a_maxzoom = glGetAttribLocation(program, "a_maxzoom");
-    a_rangeend = glGetAttribLocation(program, "a_rangeend");
-    a_rangestart = glGetAttribLocation(program, "a_rangestart");
-    a_labelminzoom = glGetAttribLocation(program, "a_labelminzoom");
+    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"));
 }
 
 void IconShader::bind(char *offset) {
     const int stride = 20;
 
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    glEnableVertexAttribArray(a_offset);
-    glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
+    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    glEnableVertexAttribArray(a_labelminzoom);
-    glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
+    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    glEnableVertexAttribArray(a_minzoom);
-    glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
+    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    glEnableVertexAttribArray(a_maxzoom);
-    glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
+    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    glEnableVertexAttribArray(a_angle);
-    glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
+    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    glEnableVertexAttribArray(a_rangeend);
-    glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    glEnableVertexAttribArray(a_rangestart);
-    glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    glEnableVertexAttribArray(a_tex);
-    glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16);
+    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    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 8353f4c6ca..3d8af9fd01 100644
--- a/src/mbgl/shader/line_shader.cpp
+++ b/src/mbgl/shader/line_shader.cpp
@@ -17,18 +17,18 @@ LineShader::LineShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
-    a_extrude = glGetAttribLocation(program, "a_extrude");
-    a_linesofar = glGetAttribLocation(program, "a_linesofar");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
+    a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
 }
 
 void LineShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
-    glEnableVertexAttribArray(a_extrude);
-    glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4);
+    CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
+    CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
 
-    glEnableVertexAttribArray(a_linesofar);
-    glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6);
+    CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
+    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 050e180e00..94c00fd0db 100644
--- a/src/mbgl/shader/linejoin_shader.cpp
+++ b/src/mbgl/shader/linejoin_shader.cpp
@@ -17,11 +17,11 @@ LinejoinShader::LinejoinShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void LinejoinShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     // Note: We're referring to the vertices in a line array, which are 8 bytes long!
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset);
+    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 954dbd2b3f..0a4503dd12 100644
--- a/src/mbgl/shader/linepattern_shader.cpp
+++ b/src/mbgl/shader/linepattern_shader.cpp
@@ -18,18 +18,18 @@ LinepatternShader::LinepatternShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
-    a_extrude = glGetAttribLocation(program, "a_extrude");
-    a_linesofar = glGetAttribLocation(program, "a_linesofar");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
+    a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
+    a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
 }
 
 void LinepatternShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
-    glEnableVertexAttribArray(a_extrude);
-    glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4);
+    CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
+    CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
 
-    glEnableVertexAttribArray(a_linesofar);
-    glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6);
+    CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
+    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 ddabfa5d0d..ef2f7dccf6 100644
--- a/src/mbgl/shader/outline_shader.cpp
+++ b/src/mbgl/shader/outline_shader.cpp
@@ -17,10 +17,10 @@ OutlineShader::OutlineShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void OutlineShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 31374bc3e8..660c90c20a 100644
--- a/src/mbgl/shader/pattern_shader.cpp
+++ b/src/mbgl/shader/pattern_shader.cpp
@@ -17,10 +17,10 @@ PatternShader::PatternShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void PatternShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 8a37837b30..4e636309b5 100644
--- a/src/mbgl/shader/plain_shader.cpp
+++ b/src/mbgl/shader/plain_shader.cpp
@@ -17,10 +17,10 @@ PlainShader::PlainShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void PlainShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 7351f7d0c4..b9cdaed6b9 100644
--- a/src/mbgl/shader/raster_shader.cpp
+++ b/src/mbgl/shader/raster_shader.cpp
@@ -19,10 +19,10 @@ RasterShader::RasterShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
+    a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
 }
 
 void RasterShader::bind(char *offset) {
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    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 b86733c0e4..05541ce4e9 100644
--- a/src/mbgl/shader/sdf_shader.cpp
+++ b/src/mbgl/shader/sdf_shader.cpp
@@ -17,75 +17,75 @@ SDFShader::SDFShader()
         return;
     }
 
-    a_pos = glGetAttribLocation(program, "a_pos");
-    a_offset = glGetAttribLocation(program, "a_offset");
-    a_tex = glGetAttribLocation(program, "a_tex");
-    a_angle = glGetAttribLocation(program, "a_angle");
-    a_minzoom = glGetAttribLocation(program, "a_minzoom");
-    a_maxzoom = glGetAttribLocation(program, "a_maxzoom");
-    a_rangeend = glGetAttribLocation(program, "a_rangeend");
-    a_rangestart = glGetAttribLocation(program, "a_rangestart");
-    a_labelminzoom = glGetAttribLocation(program, "a_labelminzoom");
+    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"));
 }
 
 void SDFGlyphShader::bind(char *offset) {
     const int stride = 16;
 
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    glEnableVertexAttribArray(a_offset);
-    glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
+    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    glEnableVertexAttribArray(a_labelminzoom);
-    glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
+    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    glEnableVertexAttribArray(a_minzoom);
-    glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
+    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    glEnableVertexAttribArray(a_maxzoom);
-    glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
+    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    glEnableVertexAttribArray(a_angle);
-    glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
+    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    glEnableVertexAttribArray(a_rangeend);
-    glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    glEnableVertexAttribArray(a_rangestart);
-    glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    glEnableVertexAttribArray(a_tex);
-    glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14);
+    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14));
 }
 
 void SDFIconShader::bind(char *offset) {
     const int stride = 20;
 
-    glEnableVertexAttribArray(a_pos);
-    glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
+    CHECK_ERROR(glEnableVertexAttribArray(a_pos));
+    CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
 
-    glEnableVertexAttribArray(a_offset);
-    glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
+    CHECK_ERROR(glEnableVertexAttribArray(a_offset));
+    CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
 
-    glEnableVertexAttribArray(a_labelminzoom);
-    glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
+    CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
 
-    glEnableVertexAttribArray(a_minzoom);
-    glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
+    CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
 
-    glEnableVertexAttribArray(a_maxzoom);
-    glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
+    CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
+    CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
 
-    glEnableVertexAttribArray(a_angle);
-    glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
+    CHECK_ERROR(glEnableVertexAttribArray(a_angle));
+    CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
 
-    glEnableVertexAttribArray(a_rangeend);
-    glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
+    CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 
-    glEnableVertexAttribArray(a_rangestart);
-    glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
+    CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
+    CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
 
-    glEnableVertexAttribArray(a_tex);
-    glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16);
+    CHECK_ERROR(glEnableVertexAttribArray(a_tex));
+    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 af6ba627e1..73270dbdde 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 = glCreateProgram();
+    program = 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) {
-                        gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength);
+                        CHECK_ERROR(gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength));
 
                         // Check if the binary was valid
                         GLint status;
-                        glGetProgramiv(program, GL_LINK_STATUS, &status);
+                        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);
-            glDeleteProgram(program);
+            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);
-            glDeleteShader(vertShader);
+            CHECK_ERROR(glDeleteShader(vertShader));
             vertShader = 0;
-            glDeleteProgram(program);
+            CHECK_ERROR(glDeleteProgram(program));
             program = 0;
             return;
         }
 
         // Attach shaders
-        glAttachShader(program, vertShader);
-        glAttachShader(program, fragShader);
+        CHECK_ERROR(glAttachShader(program, vertShader));
+        CHECK_ERROR(glAttachShader(program, fragShader));
 
         {
             if (!binaryFileName.empty() && (gl::ProgramParameteri != nullptr)) {
-                gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+                CHECK_ERROR(gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE));
             }
 
             // Link program
             GLint status;
-            glLinkProgram(program);
+            CHECK_ERROR(glLinkProgram(program));
 
-            glGetProgramiv(program, GL_LINK_STATUS, &status);
+            CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
             if (status == 0) {
                 GLint logLength;
-                glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+                CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
                 if (logLength > 0) {
                     std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-                    glGetProgramInfoLog(program, logLength, &logLength, log.get());
+                    CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
                     Log::Error(Event::Shader, "Program failed to link: %s", log.get());
                 }
 
-                glDeleteShader(vertShader);
+                CHECK_ERROR(glDeleteShader(vertShader));
                 vertShader = 0;
-                glDeleteShader(fragShader);
+                CHECK_ERROR(glDeleteShader(fragShader));
                 fragShader = 0;
-                glDeleteProgram(program);
+                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;
-        glValidateProgram(program);
+        CHECK_ERROR(glValidateProgram(program));
 
-        glGetProgramiv(program, GL_VALIDATE_STATUS, &status);
+        CHECK_ERROR(glGetProgramiv(program, GL_VALIDATE_STATUS, &status));
         if (status == 0) {
             GLint logLength;
-            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+            CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
             if (logLength > 0) {
                 std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-                glGetProgramInfoLog(program, logLength, &logLength, log.get());
+                CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
                 Log::Error(Event::Shader, "Program failed to validate: %s", log.get());
             }
 
-            glDeleteShader(vertShader);
+            CHECK_ERROR(glDeleteShader(vertShader));
             vertShader = 0;
-            glDeleteShader(fragShader);
+            CHECK_ERROR(glDeleteShader(fragShader));
             fragShader = 0;
-            glDeleteProgram(program);
+            CHECK_ERROR(glDeleteProgram(program));
             program = 0;
         }
     }
 
     if (!skipCompile) {
         // Remove the compiled shaders; they are now part of the program.
-        glDetachShader(program, vertShader);
-        glDeleteShader(vertShader);
-        glDetachShader(program, fragShader);
-        glDeleteShader(fragShader);
+        CHECK_ERROR(glDetachShader(program, vertShader));
+        CHECK_ERROR(glDeleteShader(vertShader));
+        CHECK_ERROR(glDetachShader(program, fragShader));
+        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 = glCreateShader(type);
+    *shader = CHECK_ERROR(glCreateShader(type));
     const GLchar *strings[] = { source };
     const GLsizei lengths[] = { (GLsizei)strlen(source) };
-    glShaderSource(*shader, 1, strings, lengths);
+    CHECK_ERROR(glShaderSource(*shader, 1, strings, lengths));
 
-    glCompileShader(*shader);
+    CHECK_ERROR(glCompileShader(*shader));
 
-    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+    CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
     if (status == 0) {
         GLint logLength;
-        glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
+        CHECK_ERROR(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
         if (logLength > 0) {
             std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
-            glGetShaderInfoLog(*shader, logLength, &logLength, log.get());
+            CHECK_ERROR(glGetShaderInfoLog(*shader, logLength, &logLength, log.get()));
             Log::Error(Event::Shader, "Shader failed to compile: %s", log.get());
         }
 
-        glDeleteShader(*shader);
+        CHECK_ERROR(glDeleteShader(*shader));
         *shader = 0;
         return false;
     }
 
-    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+    CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
     if (status == GL_FALSE) {
     Log::Error(Event::Shader, "Shader %s failed to compile.", name, type);
-        glDeleteShader(*shader);
+        CHECK_ERROR(glDeleteShader(*shader));
         *shader = 0;
         return false;
     }
@@ -186,11 +186,11 @@ Shader::~Shader() {
         // Retrieve the program binary
         GLsizei binaryLength;
         GLenum binaryFormat;
-        glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
+        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) {
-                gl::GetProgramBinary(program, binaryLength, NULL, &binaryFormat, binary.get());
+                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) {
-        glDeleteProgram(program);
+        CHECK_ERROR(glDeleteProgram(program));
         program = 0;
         valid = false;
     }
diff --git a/src/mbgl/shader/uniform.cpp b/src/mbgl/shader/uniform.cpp
index 24f179baf1..f2b03ac0b1 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) {
-    glUniform1f(location, t);
+    CHECK_ERROR(glUniform1f(location, t));
 }
 
 template <>
 void Uniform<int32_t>::bind(const int32_t& t) {
-    glUniform1i(location, t);
+    CHECK_ERROR(glUniform1i(location, t));
 }
 
 template <>
 void Uniform<std::array<float, 2>>::bind(const std::array<float, 2>& t) {
-    glUniform2fv(location, 1, t.data());
+    CHECK_ERROR(glUniform2fv(location, 1, t.data()));
 }
 
 template <>
 void Uniform<std::array<float, 3>>::bind(const std::array<float, 3>& t) {
-    glUniform3fv(location, 1, t.data());
+    CHECK_ERROR(glUniform3fv(location, 1, t.data()));
 }
 
 template <>
 void Uniform<std::array<float, 4>>::bind(const std::array<float, 4>& t) {
-    glUniform4fv(location, 1, t.data());
+    CHECK_ERROR(glUniform4fv(location, 1, t.data()));
 }
 
 template <>
 void UniformMatrix<2>::bind(const std::array<float, 4>& t) {
-    glUniformMatrix2fv(location, 1, GL_FALSE, t.data());
+    CHECK_ERROR(glUniformMatrix2fv(location, 1, GL_FALSE, t.data()));
 }
 
 template <>
 void UniformMatrix<3>::bind(const std::array<float, 9>& t) {
-    glUniformMatrix3fv(location, 1, GL_FALSE, t.data());
+    CHECK_ERROR(glUniformMatrix3fv(location, 1, GL_FALSE, t.data()));
 }
 
 template <>
 void UniformMatrix<4>::bind(const std::array<float, 16>& t) {
-    glUniformMatrix4fv(location, 1, GL_FALSE, t.data());
+    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 8579ae22c7..9d0b9e24b9 100644
--- a/src/mbgl/shader/uniform.hpp
+++ b/src/mbgl/shader/uniform.hpp
@@ -9,8 +9,9 @@ namespace mbgl {
 template <typename T>
 class Uniform {
 public:
-    Uniform(const GLchar* name, const Shader& shader)
-    : location(glGetUniformLocation(shader.program, name)) {}
+    Uniform(const GLchar* name, const Shader& shader) {
+         location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
+    }
 
     void operator=(const T& t) {
         if (current != t) {
@@ -31,8 +32,9 @@ class UniformMatrix {
 public:
     typedef std::array<float, C*R> T;
 
-    UniformMatrix(const GLchar* name, const Shader& shader)
-    : location(glGetUniformLocation(shader.program, name)) {}
+    UniformMatrix(const GLchar* name, const Shader& shader) {
+        location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
+    }
 
     void operator=(const T& t) {
         if (current != t) {
diff --git a/src/mbgl/util/raster.cpp b/src/mbgl/util/raster.cpp
index 56461aec5f..65a892fe98 100644
--- a/src/mbgl/util/raster.cpp
+++ b/src/mbgl/util/raster.cpp
@@ -47,23 +47,23 @@ void Raster::bind(bool linear) {
 
     if (img && !textured) {
         texture = texturePool.getTextureID();
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
 #ifndef GL_ES_VERSION_2_0
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
 #endif
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData());
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData()));
         img.reset();
         textured = true;
     } else if (textured) {
-        glBindTexture(GL_TEXTURE_2D, texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
     }
 
     GLuint new_filter = linear ? GL_LINEAR : GL_NEAREST;
     if (new_filter != this->filter) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter));
         filter = new_filter;
     }
 }
@@ -71,20 +71,20 @@ void Raster::bind(bool linear) {
 // overload ::bind for prerendered raster textures
 void Raster::bind(const GLuint custom_texture) {
     if (img && !textured) {
-        glBindTexture(GL_TEXTURE_2D, custom_texture);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData());
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+        CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData()));
         img.reset();
         textured = true;
     } else if (textured) {
-        glBindTexture(GL_TEXTURE_2D, custom_texture);
+        CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture));
     }
 
     GLuint new_filter = GL_LINEAR;
     if (new_filter != this->filter) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter));
+        CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter));
         filter = new_filter;
     }
 
diff --git a/src/mbgl/util/texture_pool.cpp b/src/mbgl/util/texture_pool.cpp
index 9c8c24b085..e4c33ce2a9 100644
--- a/src/mbgl/util/texture_pool.cpp
+++ b/src/mbgl/util/texture_pool.cpp
@@ -9,7 +9,7 @@ using namespace mbgl;
 GLuint TexturePool::getTextureID() {
     if (texture_ids.empty()) {
         GLuint new_texture_ids[TextureMax];
-        glGenTextures(TextureMax, new_texture_ids);
+        CHECK_ERROR(glGenTextures(TextureMax, new_texture_ids));
         for (uint32_t id = 0; id < TextureMax; id++) {
             texture_ids.insert(new_texture_ids[id]);
         }
@@ -51,7 +51,7 @@ void TexturePool::clearTextureIDs() {
     }
 
     if (!ids_to_remove.empty()) {
-        glDeleteTextures((GLsizei)ids_to_remove.size(), &ids_to_remove[0]);
+        CHECK_ERROR(glDeleteTextures((GLsizei)ids_to_remove.size(), &ids_to_remove[0]));
     }
 
     texture_ids.clear();