From 437fa654e3d4ebdfe28118ff8c9bdb609fbaccc1 Mon Sep 17 00:00:00 2001
From: Jamie Madill <jmadill@chromium.org>
Date: Tue, 3 May 2016 15:13:24 -0400
Subject: [PATCH] Add a ContextImpl class.

This class can contain impl-specific functionality for a Context.
This will eventually replace the Renderer class, and we can then
start passing around a gl::Context instead of gl::ContextState.

In D3D11, the ContextImpl could hold a DeferredContext, which would
enable multi-thread rendering. In GL, we can implement non-virtual
(native) Contexts. In Vulkan it might store the logical device.

BUG=angleproject:1363

Change-Id: I39617e6d1a605d1a9574832e4d322400b09867ec
Reviewed-on: https://chromium-review.googlesource.com/340745
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
---
 src/libANGLE/Context.cpp                      | 178 ++------
 src/libANGLE/Context.h                        |   5 +-
 src/libANGLE/ContextState.h                   |   2 +-
 src/libANGLE/renderer/ContextImpl.h           |  31 ++
 src/libANGLE/renderer/ImplFactory.h           |   4 +
 src/libANGLE/renderer/d3d/d3d11/Context11.h   |  29 ++
 .../renderer/d3d/d3d11/Renderer11.cpp         |   6 +
 src/libANGLE/renderer/d3d/d3d11/Renderer11.h  |   2 +
 src/libANGLE/renderer/d3d/d3d9/Context9.h     |  29 ++
 src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp  |   6 +
 src/libANGLE/renderer/d3d/d3d9/Renderer9.h    |   2 +
 src/libANGLE/renderer/gl/ContextGL.h          |  29 ++
 src/libANGLE/renderer/gl/RendererGL.cpp       |   6 +
 src/libANGLE/renderer/gl/RendererGL.h         |   2 +
 src/libANGLE/validationES.cpp                 | 431 +++++++++---------
 src/libANGLE/validationES2.cpp                | 360 +++++++--------
 src/libANGLE/validationES3.cpp                | 233 +++++-----
 src/libANGLE/validationES_unittest.cpp        |   4 +-
 src/libGLESv2.gypi                            |   4 +
 src/libGLESv2/entry_points_gles_2_0.cpp       | 369 ++++++++-------
 src/libGLESv2/entry_points_gles_2_0_ext.cpp   |  74 +--
 src/libGLESv2/entry_points_gles_3_0.cpp       | 292 ++++++------
 src/libGLESv2/global_state.cpp                |   2 +-
 src/tests/angle_unittests_utils.h             |   1 +
 24 files changed, 1090 insertions(+), 1011 deletions(-)
 create mode 100644 src/libANGLE/renderer/ContextImpl.h
 create mode 100644 src/libANGLE/renderer/d3d/d3d11/Context11.h
 create mode 100644 src/libANGLE/renderer/d3d/d3d9/Context9.h
 create mode 100644 src/libANGLE/renderer/gl/ContextGL.h

diff --git a/src/libANGLE/Context.cpp b/src/libANGLE/Context.cpp
index 683ec1868..2e89b8170 100644
--- a/src/libANGLE/Context.cpp
+++ b/src/libANGLE/Context.cpp
@@ -31,6 +31,7 @@
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/validationES.h"
+#include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/Renderer.h"
 
 namespace
@@ -133,6 +134,7 @@ Context::Context(const egl::Config *config,
                         nullptr,
                         mLimitations,
                         GetNoError(attribs)),
+      mImplementation(renderer->createContext()),
       mCompiler(nullptr),
       mRenderer(renderer),
       mClientVersion(GetClientVersion(attribs)),
@@ -261,6 +263,8 @@ Context::Context(const egl::Config *config,
     mBlitDirtyBits.set(State::DIRTY_BIT_SCISSOR);
     mBlitDirtyObjects.set(State::DIRTY_OBJECT_READ_FRAMEBUFFER);
     mBlitDirtyObjects.set(State::DIRTY_OBJECT_DRAW_FRAMEBUFFER);
+
+    handleError(mImplementation->initialize(renderer));
 }
 
 Context::~Context()
@@ -1650,7 +1654,7 @@ void Context::bindUniformLocation(GLuint program, GLint location, const GLchar *
     programObject->bindUniformLocation(location, name);
 }
 
-void Context::recordError(const Error &error)
+void Context::handleError(const Error &error)
 {
     if (error.isError())
     {
@@ -2165,56 +2169,31 @@ void Context::blitFramebuffer(GLint srcX0,
 
     syncStateForBlit();
 
-    Error error = drawFramebuffer->blit(mState, srcArea, dstArea, mask, filter, readFramebuffer);
-    if (error.isError())
-    {
-        recordError(error);
-        return;
-    }
+    handleError(drawFramebuffer->blit(mState, srcArea, dstArea, mask, filter, readFramebuffer));
 }
 
 void Context::clear(GLbitfield mask)
 {
     syncStateForClear();
-
-    Error error = mState.getDrawFramebuffer()->clear(mData, mask);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(mState.getDrawFramebuffer()->clear(mData, mask));
 }
 
 void Context::clearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *values)
 {
     syncStateForClear();
-
-    Error error = mState.getDrawFramebuffer()->clearBufferfv(mData, buffer, drawbuffer, values);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(mState.getDrawFramebuffer()->clearBufferfv(mData, buffer, drawbuffer, values));
 }
 
 void Context::clearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *values)
 {
     syncStateForClear();
-
-    Error error = mState.getDrawFramebuffer()->clearBufferuiv(mData, buffer, drawbuffer, values);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(mState.getDrawFramebuffer()->clearBufferuiv(mData, buffer, drawbuffer, values));
 }
 
 void Context::clearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *values)
 {
     syncStateForClear();
-
-    Error error = mState.getDrawFramebuffer()->clearBufferiv(mData, buffer, drawbuffer, values);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(mState.getDrawFramebuffer()->clearBufferiv(mData, buffer, drawbuffer, values));
 }
 
 void Context::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
@@ -2230,12 +2209,7 @@ void Context::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLin
     }
 
     syncStateForClear();
-
-    Error error = framebufferObject->clearBufferfi(mData, buffer, drawbuffer, depth, stencil);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(framebufferObject->clearBufferfi(mData, buffer, drawbuffer, depth, stencil));
 }
 
 void Context::readPixels(GLint x,
@@ -2252,11 +2226,7 @@ void Context::readPixels(GLint x,
     ASSERT(framebufferObject);
 
     Rectangle area(x, y, width, height);
-    Error error = framebufferObject->readPixels(mState, area, format, type, pixels);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(framebufferObject->readPixels(mState, area, format, type, pixels));
 }
 
 void Context::copyTexImage2D(GLenum target,
@@ -2276,11 +2246,7 @@ void Context::copyTexImage2D(GLenum target,
     const Framebuffer *framebuffer = mState.getReadFramebuffer();
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error = texture->copyImage(target, level, sourceArea, internalformat, framebuffer);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->copyImage(target, level, sourceArea, internalformat, framebuffer));
 }
 
 void Context::copyTexSubImage2D(GLenum target,
@@ -2301,11 +2267,7 @@ void Context::copyTexSubImage2D(GLenum target,
     const Framebuffer *framebuffer = mState.getReadFramebuffer();
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error = texture->copySubImage(target, level, destOffset, sourceArea, framebuffer);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->copySubImage(target, level, destOffset, sourceArea, framebuffer));
 }
 
 void Context::copyTexSubImage3D(GLenum target,
@@ -2326,11 +2288,7 @@ void Context::copyTexSubImage3D(GLenum target,
 
     const Framebuffer *framebuffer = mState.getReadFramebuffer();
     Texture *texture               = getTargetTexture(target);
-    Error error = texture->copySubImage(target, level, destOffset, sourceArea, framebuffer);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->copySubImage(target, level, destOffset, sourceArea, framebuffer));
 }
 
 void Context::framebufferTexture2D(GLenum target,
@@ -2450,11 +2408,7 @@ void Context::discardFramebuffer(GLenum target, GLsizei numAttachments, const GL
 
     // The specification isn't clear what should be done when the framebuffer isn't complete.
     // We leave it up to the framebuffer implementation to decide what to do.
-    Error error = framebuffer->discard(numAttachments, attachments);
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(framebuffer->discard(numAttachments, attachments));
 }
 
 void Context::invalidateFramebuffer(GLenum target,
@@ -2467,15 +2421,12 @@ void Context::invalidateFramebuffer(GLenum target,
     Framebuffer *framebuffer = mState.getTargetFramebuffer(target);
     ASSERT(framebuffer);
 
-    if (framebuffer->checkStatus(mData) == GL_FRAMEBUFFER_COMPLETE)
+    if (framebuffer->checkStatus(mData) != GL_FRAMEBUFFER_COMPLETE)
     {
-        Error error = framebuffer->invalidate(numAttachments, attachments);
-        if (error.isError())
-        {
-            recordError(error);
-            return;
-        }
+        return;
     }
+
+    handleError(framebuffer->invalidate(numAttachments, attachments));
 }
 
 void Context::invalidateSubFramebuffer(GLenum target,
@@ -2492,16 +2443,13 @@ void Context::invalidateSubFramebuffer(GLenum target,
     Framebuffer *framebuffer = mState.getTargetFramebuffer(target);
     ASSERT(framebuffer);
 
-    if (framebuffer->checkStatus(mData) == GL_FRAMEBUFFER_COMPLETE)
+    if (framebuffer->checkStatus(mData) != GL_FRAMEBUFFER_COMPLETE)
     {
-        Rectangle area(x, y, width, height);
-        Error error = framebuffer->invalidateSub(numAttachments, attachments, area);
-        if (error.isError())
-        {
-            recordError(error);
-            return;
-        }
+        return;
     }
+
+    Rectangle area(x, y, width, height);
+    handleError(framebuffer->invalidateSub(numAttachments, attachments, area));
 }
 
 void Context::texImage2D(GLenum target,
@@ -2519,12 +2467,8 @@ void Context::texImage2D(GLenum target,
     Extents size(width, height, 1);
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error = texture->setImage(mState.getUnpackState(), target, level, internalformat, size,
-                                    format, type, reinterpret_cast<const uint8_t *>(pixels));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setImage(mState.getUnpackState(), target, level, internalformat, size,
+                                  format, type, reinterpret_cast<const uint8_t *>(pixels)));
 }
 
 void Context::texImage3D(GLenum target,
@@ -2542,12 +2486,8 @@ void Context::texImage3D(GLenum target,
 
     Extents size(width, height, depth);
     Texture *texture = getTargetTexture(target);
-    Error error = texture->setImage(mState.getUnpackState(), target, level, internalformat, size,
-                                    format, type, reinterpret_cast<const uint8_t *>(pixels));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setImage(mState.getUnpackState(), target, level, internalformat, size,
+                                  format, type, reinterpret_cast<const uint8_t *>(pixels)));
 }
 
 void Context::texSubImage2D(GLenum target,
@@ -2571,12 +2511,8 @@ void Context::texSubImage2D(GLenum target,
     Box area(xoffset, yoffset, 0, width, height, 1);
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error = texture->setSubImage(mState.getUnpackState(), target, level, area, format, type,
-                                       reinterpret_cast<const uint8_t *>(pixels));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setSubImage(mState.getUnpackState(), target, level, area, format, type,
+                                     reinterpret_cast<const uint8_t *>(pixels)));
 }
 
 void Context::texSubImage3D(GLenum target,
@@ -2601,12 +2537,8 @@ void Context::texSubImage3D(GLenum target,
 
     Box area(xoffset, yoffset, zoffset, width, height, depth);
     Texture *texture = getTargetTexture(target);
-    Error error = texture->setSubImage(mState.getUnpackState(), target, level, area, format, type,
-                                       reinterpret_cast<const uint8_t *>(pixels));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setSubImage(mState.getUnpackState(), target, level, area, format, type,
+                                     reinterpret_cast<const uint8_t *>(pixels)));
 }
 
 void Context::compressedTexImage2D(GLenum target,
@@ -2623,13 +2555,9 @@ void Context::compressedTexImage2D(GLenum target,
     Extents size(width, height, 1);
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error =
-        texture->setCompressedImage(mState.getUnpackState(), target, level, internalformat, size,
-                                    imageSize, reinterpret_cast<const uint8_t *>(data));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setCompressedImage(mState.getUnpackState(), target, level, internalformat,
+                                            size, imageSize,
+                                            reinterpret_cast<const uint8_t *>(data)));
 }
 
 void Context::compressedTexImage3D(GLenum target,
@@ -2646,13 +2574,9 @@ void Context::compressedTexImage3D(GLenum target,
 
     Extents size(width, height, depth);
     Texture *texture = getTargetTexture(target);
-    Error error =
-        texture->setCompressedImage(mState.getUnpackState(), target, level, internalformat, size,
-                                    imageSize, reinterpret_cast<const uint8_t *>(data));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setCompressedImage(mState.getUnpackState(), target, level, internalformat,
+                                            size, imageSize,
+                                            reinterpret_cast<const uint8_t *>(data)));
 }
 
 void Context::compressedTexSubImage2D(GLenum target,
@@ -2670,13 +2594,8 @@ void Context::compressedTexSubImage2D(GLenum target,
     Box area(xoffset, yoffset, 0, width, height, 1);
     Texture *texture =
         getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-    Error error =
-        texture->setCompressedSubImage(mState.getUnpackState(), target, level, area, format,
-                                       imageSize, reinterpret_cast<const uint8_t *>(data));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setCompressedSubImage(mState.getUnpackState(), target, level, area, format,
+                                               imageSize, reinterpret_cast<const uint8_t *>(data)));
 }
 
 void Context::compressedTexSubImage3D(GLenum target,
@@ -2701,13 +2620,8 @@ void Context::compressedTexSubImage3D(GLenum target,
 
     Box area(xoffset, yoffset, zoffset, width, height, depth);
     Texture *texture = getTargetTexture(target);
-    Error error =
-        texture->setCompressedSubImage(mState.getUnpackState(), target, level, area, format,
-                                       imageSize, reinterpret_cast<const uint8_t *>(data));
-    if (error.isError())
-    {
-        recordError(error);
-    }
+    handleError(texture->setCompressedSubImage(mState.getUnpackState(), target, level, area, format,
+                                               imageSize, reinterpret_cast<const uint8_t *>(data)));
 }
 
 void Context::getBufferPointerv(GLenum target, GLenum /*pname*/, void **params)
@@ -2733,7 +2647,7 @@ GLvoid *Context::mapBuffer(GLenum target, GLenum access)
     Error error = buffer->map(access);
     if (error.isError())
     {
-        recordError(error);
+        handleError(error);
         return nullptr;
     }
 
@@ -2749,7 +2663,7 @@ GLboolean Context::unmapBuffer(GLenum target)
     Error error = buffer->unmap(&result);
     if (error.isError())
     {
-        recordError(error);
+        handleError(error);
         return GL_FALSE;
     }
 
@@ -2767,7 +2681,7 @@ GLvoid *Context::mapBufferRange(GLenum target,
     Error error = buffer->mapRange(offset, length, access);
     if (error.isError())
     {
-        recordError(error);
+        handleError(error);
         return nullptr;
     }
 
diff --git a/src/libANGLE/Context.h b/src/libANGLE/Context.h
index 9d983751a..d9736e804 100644
--- a/src/libANGLE/Context.h
+++ b/src/libANGLE/Context.h
@@ -26,6 +26,7 @@
 
 namespace rx
 {
+class ContextImpl;
 class Renderer;
 }
 
@@ -388,7 +389,7 @@ class Context final : public ValidationContext
 
     void bindUniformLocation(GLuint program, GLint location, const GLchar *name);
 
-    void recordError(const Error &error) override;
+    void handleError(const Error &error) override;
 
     GLenum getError();
     GLenum getResetStatus();
@@ -432,6 +433,8 @@ class Context final : public ValidationContext
 
     void initCaps(GLuint clientVersion);
 
+    std::unique_ptr<rx::ContextImpl> mImplementation;
+
     // Caps to use for validation
     Caps mCaps;
     TextureCapsMap mTextureCaps;
diff --git a/src/libANGLE/ContextState.h b/src/libANGLE/ContextState.h
index 4f7f1c86b..1ce2bfc06 100644
--- a/src/libANGLE/ContextState.h
+++ b/src/libANGLE/ContextState.h
@@ -51,7 +51,7 @@ class ValidationContext : angle::NonCopyable
                       bool skipValidation);
     virtual ~ValidationContext() {}
 
-    virtual void recordError(const Error &error) = 0;
+    virtual void handleError(const Error &error) = 0;
 
     const ContextState &getData() const { return mData; }
     int getClientVersion() const { return mData.clientVersion; }
diff --git a/src/libANGLE/renderer/ContextImpl.h b/src/libANGLE/renderer/ContextImpl.h
new file mode 100644
index 000000000..d12ded532
--- /dev/null
+++ b/src/libANGLE/renderer/ContextImpl.h
@@ -0,0 +1,31 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ContextImpl:
+//   Implementation-specific functionality associated with a GL Context.
+//
+
+#ifndef LIBANGLE_RENDERER_CONTEXTIMPL_H_
+#define LIBANGLE_RENDERER_CONTEXTIMPL_H_
+
+#include "common/angleutils.h"
+#include "libANGLE/Error.h"
+
+namespace rx
+{
+class Renderer;
+
+class ContextImpl : angle::NonCopyable
+{
+  public:
+    ContextImpl() {}
+    virtual ~ContextImpl() {}
+
+    virtual gl::Error initialize(Renderer *renderer) = 0;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_CONTEXTIMPL_H_
diff --git a/src/libANGLE/renderer/ImplFactory.h b/src/libANGLE/renderer/ImplFactory.h
index 727e47a80..577490d3c 100644
--- a/src/libANGLE/renderer/ImplFactory.h
+++ b/src/libANGLE/renderer/ImplFactory.h
@@ -19,6 +19,7 @@ namespace rx
 {
 class BufferImpl;
 class CompilerImpl;
+class ContextImpl;
 class FenceNVImpl;
 class FenceSyncImpl;
 class FramebufferImpl;
@@ -37,6 +38,9 @@ class ImplFactory : angle::NonCopyable
     ImplFactory() {}
     virtual ~ImplFactory() {}
 
+    // Context creation
+    virtual ContextImpl *createContext() = 0;
+
     // Shader creation
     virtual CompilerImpl *createCompiler() = 0;
     virtual ShaderImpl *createShader(const gl::ShaderState &data) = 0;
diff --git a/src/libANGLE/renderer/d3d/d3d11/Context11.h b/src/libANGLE/renderer/d3d/d3d11/Context11.h
new file mode 100644
index 000000000..e6e967cec
--- /dev/null
+++ b/src/libANGLE/renderer/d3d/d3d11/Context11.h
@@ -0,0 +1,29 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Context11:
+//   D3D11-specific functionality associated with a GL Context.
+//
+
+#ifndef LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
+#define LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
+
+#include "libANGLE/renderer/ContextImpl.h"
+
+namespace rx
+{
+
+class Context11 : public ContextImpl
+{
+  public:
+    Context11() {}
+    ~Context11() override {}
+
+    gl::Error initialize(Renderer *renderer) override { return gl::NoError(); }
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
diff --git a/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp b/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
index 4fcf91995..957d09f9b 100644
--- a/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
+++ b/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
@@ -25,6 +25,7 @@
 #include "libANGLE/renderer/d3d/d3d11/Blit11.h"
 #include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/Clear11.h"
+#include "libANGLE/renderer/d3d/d3d11/Context11.h"
 #include "libANGLE/renderer/d3d/d3d11/dxgi_support_table.h"
 #include "libANGLE/renderer/d3d/d3d11/Fence11.h"
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
@@ -1143,6 +1144,11 @@ SwapChainD3D *Renderer11::createSwapChain(NativeWindowD3D *nativeWindow,
                            depthBufferFormat, orientation);
 }
 
+ContextImpl *Renderer11::createContext()
+{
+    return new Context11;
+}
+
 CompilerImpl *Renderer11::createCompiler()
 {
     if (mRenderer11DeviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3)
diff --git a/src/libANGLE/renderer/d3d/d3d11/Renderer11.h b/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
index 5328f477f..15fb35664 100644
--- a/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
+++ b/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
@@ -124,6 +124,8 @@ class Renderer11 : public RendererD3D
                                   GLenum depthBufferFormat,
                                   EGLint orientation) override;
 
+    ContextImpl *createContext() override;
+
     CompilerImpl *createCompiler() override;
 
     virtual gl::Error generateSwizzle(gl::Texture *texture);
diff --git a/src/libANGLE/renderer/d3d/d3d9/Context9.h b/src/libANGLE/renderer/d3d/d3d9/Context9.h
new file mode 100644
index 000000000..5a5e3cc0e
--- /dev/null
+++ b/src/libANGLE/renderer/d3d/d3d9/Context9.h
@@ -0,0 +1,29 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Context9:
+//   D3D9-specific functionality associated with a GL Context.
+//
+
+#ifndef LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_
+#define LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_
+
+#include "libANGLE/renderer/ContextImpl.h"
+
+namespace rx
+{
+
+class Context9 : public ContextImpl
+{
+  public:
+    Context9() {}
+    ~Context9() override {}
+
+    gl::Error initialize(Renderer *renderer) override { return gl::NoError(); }
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_D3D9_CONTEXT9_H_
diff --git a/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp b/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
index f92f97765..80d266d3d 100644
--- a/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
+++ b/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
@@ -23,6 +23,7 @@
 #include "libANGLE/Renderbuffer.h"
 #include "libANGLE/renderer/d3d/d3d9/Blit9.h"
 #include "libANGLE/renderer/d3d/d3d9/Buffer9.h"
+#include "libANGLE/renderer/d3d/d3d9/Context9.h"
 #include "libANGLE/renderer/d3d/d3d9/Fence9.h"
 #include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
 #include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h"
@@ -680,6 +681,11 @@ SwapChainD3D *Renderer9::createSwapChain(NativeWindowD3D *nativeWindow,
                           depthBufferFormat, orientation);
 }
 
+ContextImpl *Renderer9::createContext()
+{
+    return new Context9;
+}
+
 CompilerImpl *Renderer9::createCompiler()
 {
     return new CompilerD3D(SH_HLSL_3_0_OUTPUT);
diff --git a/src/libANGLE/renderer/d3d/d3d9/Renderer9.h b/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
index f328f825a..1e6d26cfe 100644
--- a/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
+++ b/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
@@ -90,6 +90,8 @@ class Renderer9 : public RendererD3D
                                   GLenum depthBufferFormat,
                                   EGLint orientation) override;
 
+    ContextImpl *createContext() override;
+
     CompilerImpl *createCompiler() override;
 
     gl::Error allocateEventQuery(IDirect3DQuery9 **outQuery);
diff --git a/src/libANGLE/renderer/gl/ContextGL.h b/src/libANGLE/renderer/gl/ContextGL.h
new file mode 100644
index 000000000..eb16eda20
--- /dev/null
+++ b/src/libANGLE/renderer/gl/ContextGL.h
@@ -0,0 +1,29 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ContextGL:
+//   OpenGL-specific functionality associated with a GL Context.
+//
+
+#ifndef LIBANGLE_RENDERER_GL_CONTEXTGL_H_
+#define LIBANGLE_RENDERER_GL_CONTEXTGL_H_
+
+#include "libANGLE/renderer/ContextImpl.h"
+
+namespace rx
+{
+
+class ContextGL : public ContextImpl
+{
+  public:
+    ContextGL() {}
+    ~ContextGL() override {}
+
+    gl::Error initialize(Renderer *renderer) override { return gl::NoError(); }
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_GL_CONTEXTGL_H_
diff --git a/src/libANGLE/renderer/gl/RendererGL.cpp b/src/libANGLE/renderer/gl/RendererGL.cpp
index 086f39081..0cc8d85cc 100644
--- a/src/libANGLE/renderer/gl/RendererGL.cpp
+++ b/src/libANGLE/renderer/gl/RendererGL.cpp
@@ -17,6 +17,7 @@
 #include "libANGLE/renderer/gl/BlitGL.h"
 #include "libANGLE/renderer/gl/BufferGL.h"
 #include "libANGLE/renderer/gl/CompilerGL.h"
+#include "libANGLE/renderer/gl/ContextGL.h"
 #include "libANGLE/renderer/gl/FenceNVGL.h"
 #include "libANGLE/renderer/gl/FenceSyncGL.h"
 #include "libANGLE/renderer/gl/FramebufferGL.h"
@@ -262,6 +263,11 @@ gl::Error RendererGL::drawRangeElements(const gl::ContextState &data,
     return gl::Error(GL_NO_ERROR);
 }
 
+ContextImpl *RendererGL::createContext()
+{
+    return new ContextGL;
+}
+
 CompilerImpl *RendererGL::createCompiler()
 {
     return new CompilerGL(mFunctions);
diff --git a/src/libANGLE/renderer/gl/RendererGL.h b/src/libANGLE/renderer/gl/RendererGL.h
index 5f97d0eac..aa6ad92d7 100644
--- a/src/libANGLE/renderer/gl/RendererGL.h
+++ b/src/libANGLE/renderer/gl/RendererGL.h
@@ -60,6 +60,8 @@ class RendererGL : public Renderer
                                 const GLvoid *indices,
                                 const gl::IndexRange &indexRange) override;
 
+    ContextImpl *createContext() override;
+
     // Shader creation
     CompilerImpl *createCompiler() override;
     ShaderImpl *createShader(const gl::ShaderState &data) override;
diff --git a/src/libANGLE/validationES.cpp b/src/libANGLE/validationES.cpp
index a41bfa75e..0b589ff2e 100644
--- a/src/libANGLE/validationES.cpp
+++ b/src/libANGLE/validationES.cpp
@@ -75,7 +75,7 @@ bool ValidateDrawAttribs(ValidationContext *context, GLint primcount, GLint maxV
                     // enough backing data.
                     if (attribDataSize + attribOffset > buffer->getSize())
                     {
-                        context->recordError(
+                        context->handleError(
                             Error(GL_INVALID_OPERATION,
                                   "Vertex buffer is not big enough for the draw call"));
                         return false;
@@ -86,7 +86,7 @@ bool ValidateDrawAttribs(ValidationContext *context, GLint primcount, GLint maxV
             {
                 // This is an application error that would normally result in a crash,
                 // but we catch it and return an error
-                context->recordError(Error(
+                context->handleError(Error(
                     GL_INVALID_OPERATION, "An enabled vertex array has no buffer and no pointer."));
                 return false;
             }
@@ -415,12 +415,12 @@ Program *GetValidProgram(Context *context, GLuint id)
     {
         if (context->getShader(id))
         {
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION, "Expected a program name, but found a shader name"));
         }
         else
         {
-            context->recordError(Error(GL_INVALID_VALUE, "Program name is not valid"));
+            context->handleError(Error(GL_INVALID_VALUE, "Program name is not valid"));
         }
     }
 
@@ -437,12 +437,12 @@ Shader *GetValidShader(Context *context, GLuint id)
     {
         if (context->getProgram(id))
         {
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION, "Expected a shader name, but found a program name"));
         }
         else
         {
-            context->recordError(Error(GL_INVALID_VALUE, "Shader name is invalid"));
+            context->handleError(Error(GL_INVALID_VALUE, "Shader name is invalid"));
         }
     }
 
@@ -457,7 +457,7 @@ bool ValidateAttachmentTarget(gl::Context *context, GLenum attachment)
 
         if (colorAttachment >= context->getCaps().maxColorAttachments)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -472,13 +472,13 @@ bool ValidateAttachmentTarget(gl::Context *context, GLenum attachment)
           case GL_DEPTH_STENCIL_ATTACHMENT:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
     }
@@ -494,20 +494,20 @@ bool ValidateRenderbufferStorageParametersBase(gl::Context *context, GLenum targ
       case GL_RENDERBUFFER:
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (width < 0 || height < 0 || samples < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
     if (!formatCaps.renderable)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -517,20 +517,20 @@ bool ValidateRenderbufferStorageParametersBase(gl::Context *context, GLenum targ
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
     if (formatInfo.pixelBytes == 0)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (static_cast<GLuint>(std::max(width, height)) > context->getCaps().maxRenderbufferSize)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     GLuint handle = context->getState().getRenderbufferId();
     if (handle == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -547,7 +547,7 @@ bool ValidateRenderbufferStorageParametersANGLE(gl::Context *context, GLenum tar
     // generated.
     if (static_cast<GLuint>(samples) > context->getCaps().maxSamples)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -560,7 +560,7 @@ bool ValidateRenderbufferStorageParametersANGLE(gl::Context *context, GLenum tar
         const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
         {
-            context->recordError(Error(GL_OUT_OF_MEMORY));
+            context->handleError(Error(GL_OUT_OF_MEMORY));
             return false;
         }
     }
@@ -573,7 +573,7 @@ bool ValidateFramebufferRenderbufferParameters(gl::Context *context, GLenum targ
 {
     if (!ValidFramebufferTarget(target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -582,7 +582,8 @@ bool ValidateFramebufferRenderbufferParameters(gl::Context *context, GLenum targ
     ASSERT(framebuffer);
     if (framebuffer->id() == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Cannot change default FBO's attachments"));
+        context->handleError(
+            Error(GL_INVALID_OPERATION, "Cannot change default FBO's attachments"));
         return false;
     }
 
@@ -599,7 +600,7 @@ bool ValidateFramebufferRenderbufferParameters(gl::Context *context, GLenum targ
     {
         if (!context->getRenderbuffer(renderbuffer))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -626,13 +627,13 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
       case GL_LINEAR:
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -647,13 +648,13 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
     // color buffer, leaving only nearest being unfiltered from above
     if ((mask & ~GL_COLOR_BUFFER_BIT) != 0 && filter != GL_NEAREST)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (context->getState().getReadFramebuffer()->id() == context->getState().getDrawFramebuffer()->id())
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -662,25 +663,25 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
 
     if (!readFramebuffer || !drawFramebuffer)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if (!readFramebuffer->checkStatus(context->getData()))
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if (!drawFramebuffer->checkStatus(context->getData()))
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if (drawFramebuffer->getSamples(context->getData()) != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -727,7 +728,7 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
 
                         if (readFixedOrFloat != drawFixedOrFloat)
                         {
-                            context->recordError(Error(GL_INVALID_OPERATION,
+                            context->handleError(Error(GL_INVALID_OPERATION,
                                                        "If the read buffer contains fixed-point or "
                                                        "floating-point values, the draw buffer "
                                                        "must as well."));
@@ -736,7 +737,7 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
                     }
                     else if (readFixedPoint != drawFixedPoint)
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION,
+                        context->handleError(Error(GL_INVALID_OPERATION,
                                                    "If the read buffer contains fixed-point "
                                                    "values, the draw buffer must as well."));
                         return false;
@@ -745,19 +746,19 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
                     if (readComponentType == GL_UNSIGNED_INT &&
                         drawComponentType != GL_UNSIGNED_INT)
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return false;
                     }
 
                     if (readComponentType == GL_INT && drawComponentType != GL_INT)
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return false;
                     }
 
                     if (readColorBuffer->getSamples() > 0 && (readInternalFormat != drawInternalFormat || !sameBounds))
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return false;
                     }
                 }
@@ -765,7 +766,7 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
 
             if ((readFormatInfo.componentType == GL_INT || readFormatInfo.componentType == GL_UNSIGNED_INT) && filter == GL_LINEAR)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
         }
@@ -784,13 +785,13 @@ bool ValidateBlitFramebufferParameters(gl::Context *context,
             {
                 if (readBuffer->getInternalFormat() != drawBuffer->getInternalFormat())
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
 
                 if (readBuffer->getSamples() > 0 && !sameBounds)
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
             }
@@ -823,13 +824,13 @@ bool ValidateGetVertexAttribParameters(Context *context, GLenum pname)
       case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         return true;
 
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 }
@@ -853,7 +854,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           // written against ES2.
           if (context->getClientVersion() < 3 || target == GL_TEXTURE_EXTERNAL_OES)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -875,13 +876,13 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
               if (target == GL_TEXTURE_EXTERNAL_OES)
               {
                   // OES_EGL_image_external specifies this error.
-                  context->recordError(Error(
+                  context->handleError(Error(
                       GL_INVALID_ENUM, "external textures only support CLAMP_TO_EDGE wrap mode"));
                   return false;
               }
               return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
@@ -898,14 +899,14 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
               if (target == GL_TEXTURE_EXTERNAL_OES)
               {
                   // OES_EGL_image_external specifies this error.
-                  context->recordError(
+                  context->handleError(
                       Error(GL_INVALID_ENUM,
                             "external textures only support NEAREST and LINEAR filtering"));
                   return false;
               }
               return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -917,7 +918,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           case GL_LINEAR:
             return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -929,7 +930,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
             return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -937,14 +938,14 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
         if (!context->getExtensions().textureFilterAnisotropic)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
         // we assume the parameter passed to this validation method is truncated, not rounded
         if (param < 1)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         return true;
@@ -962,7 +963,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           case GL_COMPARE_REF_TO_TEXTURE:
             return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -981,7 +982,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           case GL_NEVER:
             return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -1000,7 +1001,7 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
           case GL_ONE:
             return true;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -1009,13 +1010,13 @@ bool ValidateTexParamParameters(gl::Context *context, GLenum target, GLenum pnam
       case GL_TEXTURE_MAX_LEVEL:
         if (param < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         return true;
 
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 }
@@ -1036,7 +1037,7 @@ bool ValidateSamplerObjectParameter(gl::Context *context, GLenum pname)
         return true;
 
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 }
@@ -1052,7 +1053,7 @@ bool ValidateReadPixels(Context *context,
 {
     if (width < 0 || height < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "width and height must be positive"));
+        context->handleError(Error(GL_INVALID_VALUE, "width and height must be positive"));
         return false;
     }
 
@@ -1061,21 +1062,21 @@ bool ValidateReadPixels(Context *context,
 
     if (framebuffer->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if (context->getState().getReadFramebuffer()->id() != 0 &&
         framebuffer->getSamples(context->getData()) != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     const FramebufferAttachment *readBuffer = framebuffer->getReadColorbuffer();
     if (!readBuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1089,7 +1090,7 @@ bool ValidateReadPixels(Context *context,
 
     if (!(currentFormat == format && currentType == type) && !validReadFormat)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1108,7 +1109,7 @@ bool ValidateReadnPixelsEXT(Context *context,
 {
     if (bufSize < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "bufSize must be a positive number"));
+        context->handleError(Error(GL_INVALID_VALUE, "bufSize must be a positive number"));
         return false;
     }
 
@@ -1122,7 +1123,7 @@ bool ValidateReadnPixelsEXT(Context *context,
     int requiredSize = outputPitch * height;
     if (requiredSize > bufSize)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1134,7 +1135,7 @@ bool ValidateGenQueriesEXT(gl::Context *context, GLsizei n)
     if (!context->getExtensions().occlusionQueryBoolean &&
         !context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
 
@@ -1146,7 +1147,7 @@ bool ValidateDeleteQueriesEXT(gl::Context *context, GLsizei n)
     if (!context->getExtensions().occlusionQueryBoolean &&
         !context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
 
@@ -1157,13 +1158,13 @@ bool ValidateBeginQueryBase(gl::Context *context, GLenum target, GLuint id)
 {
     if (!ValidQueryType(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid query target"));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid query target"));
         return false;
     }
 
     if (id == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query id is 0"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query id is 0"));
         return false;
     }
 
@@ -1185,7 +1186,7 @@ bool ValidateBeginQueryBase(gl::Context *context, GLenum target, GLuint id)
 
     if (context->getState().isQueryActive(target))
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Other query is active"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Other query is active"));
         return false;
     }
 
@@ -1194,14 +1195,14 @@ bool ValidateBeginQueryBase(gl::Context *context, GLenum target, GLuint id)
     // check that name was obtained with glGenQueries
     if (!queryObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Invalid query id"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Invalid query id"));
         return false;
     }
 
     // check for type mismatch
     if (queryObject->getType() != target)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query type does not match target"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query type does not match target"));
         return false;
     }
 
@@ -1213,7 +1214,7 @@ bool ValidateBeginQueryEXT(gl::Context *context, GLenum target, GLuint id)
     if (!context->getExtensions().occlusionQueryBoolean &&
         !context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
 
@@ -1224,7 +1225,7 @@ bool ValidateEndQueryBase(gl::Context *context, GLenum target)
 {
     if (!ValidQueryType(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid query target"));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid query target"));
         return false;
     }
 
@@ -1232,7 +1233,7 @@ bool ValidateEndQueryBase(gl::Context *context, GLenum target)
 
     if (queryObject == nullptr)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query target not active"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query target not active"));
         return false;
     }
 
@@ -1244,7 +1245,7 @@ bool ValidateEndQueryEXT(gl::Context *context, GLenum target)
     if (!context->getExtensions().occlusionQueryBoolean &&
         !context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
 
@@ -1255,26 +1256,26 @@ bool ValidateQueryCounterEXT(Context *context, GLuint id, GLenum target)
 {
     if (!context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Disjoint timer query not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Disjoint timer query not enabled"));
         return false;
     }
 
     if (target != GL_TIMESTAMP_EXT)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid query target"));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid query target"));
         return false;
     }
 
     Query *queryObject = context->getQuery(id, true, target);
     if (queryObject == nullptr)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Invalid query id"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Invalid query id"));
         return false;
     }
 
     if (context->getState().isQueryActive(queryObject))
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query is active"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query is active"));
         return false;
     }
 
@@ -1285,7 +1286,7 @@ bool ValidateGetQueryivBase(Context *context, GLenum target, GLenum pname)
 {
     if (!ValidQueryType(context, target) && target != GL_TIMESTAMP_EXT)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid query type"));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid query type"));
         return false;
     }
 
@@ -1294,7 +1295,7 @@ bool ValidateGetQueryivBase(Context *context, GLenum target, GLenum pname)
         case GL_CURRENT_QUERY_EXT:
             if (target == GL_TIMESTAMP_EXT)
             {
-                context->recordError(
+                context->handleError(
                     Error(GL_INVALID_ENUM, "Cannot use current query for timestamp"));
                 return false;
             }
@@ -1303,12 +1304,12 @@ bool ValidateGetQueryivBase(Context *context, GLenum target, GLenum pname)
             if (!context->getExtensions().disjointTimerQuery ||
                 (target != GL_TIMESTAMP_EXT && target != GL_TIME_ELAPSED_EXT))
             {
-                context->recordError(Error(GL_INVALID_ENUM, "Invalid pname"));
+                context->handleError(Error(GL_INVALID_ENUM, "Invalid pname"));
                 return false;
             }
             break;
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid pname"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid pname"));
             return false;
     }
 
@@ -1320,7 +1321,7 @@ bool ValidateGetQueryivEXT(Context *context, GLenum target, GLenum pname, GLint
     if (!context->getExtensions().occlusionQueryBoolean &&
         !context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
 
@@ -1333,13 +1334,13 @@ bool ValidateGetQueryObjectValueBase(Context *context, GLuint id, GLenum pname)
 
     if (!queryObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query does not exist"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query does not exist"));
         return false;
     }
 
     if (context->getState().isQueryActive(queryObject))
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query currently active"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query currently active"));
         return false;
     }
 
@@ -1350,7 +1351,7 @@ bool ValidateGetQueryObjectValueBase(Context *context, GLuint id, GLenum pname)
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid pname enum"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid pname enum"));
             return false;
     }
 
@@ -1361,7 +1362,7 @@ bool ValidateGetQueryObjectivEXT(Context *context, GLuint id, GLenum pname, GLin
 {
     if (!context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, id, pname);
@@ -1372,7 +1373,7 @@ bool ValidateGetQueryObjectuivEXT(Context *context, GLuint id, GLenum pname, GLu
     if (!context->getExtensions().disjointTimerQuery &&
         !context->getExtensions().occlusionQueryBoolean)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, id, pname);
@@ -1382,7 +1383,7 @@ bool ValidateGetQueryObjecti64vEXT(Context *context, GLuint id, GLenum pname, GL
 {
     if (!context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, id, pname);
@@ -1392,7 +1393,7 @@ bool ValidateGetQueryObjectui64vEXT(Context *context, GLuint id, GLenum pname, G
 {
     if (!context->getExtensions().disjointTimerQuery)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Timer query extension not enabled"));
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, id, pname);
@@ -1406,14 +1407,14 @@ static bool ValidateUniformCommonBase(gl::Context *context,
 {
     if (count < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     gl::Program *program = context->getState().getProgram();
     if (!program)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1425,7 +1426,7 @@ static bool ValidateUniformCommonBase(gl::Context *context,
 
     if (!program->isValidUniformLocation(location))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1434,7 +1435,7 @@ static bool ValidateUniformCommonBase(gl::Context *context,
     // attempting to write an array to a non-array uniform is an INVALID_OPERATION
     if (!uniform.isArray() && count > 1)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1447,7 +1448,7 @@ bool ValidateUniform(gl::Context *context, GLenum uniformType, GLint location, G
     // Check for ES3 uniform entry points
     if (VariableComponentType(uniformType) == GL_UNSIGNED_INT && context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1461,7 +1462,7 @@ bool ValidateUniform(gl::Context *context, GLenum uniformType, GLint location, G
     bool samplerUniformCheck = (IsSamplerType(uniform->type) && uniformType == GL_INT);
     if (!samplerUniformCheck && uniformType != uniform->type && targetBoolType != uniform->type)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1476,13 +1477,13 @@ bool ValidateUniformMatrix(gl::Context *context, GLenum matrixType, GLint locati
     int cols = VariableColumnCount(matrixType);
     if (rows != cols && context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (transpose != GL_FALSE && context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1494,7 +1495,7 @@ bool ValidateUniformMatrix(gl::Context *context, GLenum matrixType, GLint locati
 
     if (uniform->type != matrixType)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1505,7 +1506,7 @@ bool ValidateStateQuery(gl::Context *context, GLenum pname, GLenum *nativeType,
 {
     if (!context->getQueryParameterInfo(pname, nativeType, numParams))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1517,7 +1518,7 @@ bool ValidateStateQuery(gl::Context *context, GLenum pname, GLenum *nativeType,
 
         if (colorAttachment >= caps.maxDrawBuffers)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -1532,7 +1533,7 @@ bool ValidateStateQuery(gl::Context *context, GLenum pname, GLenum *nativeType,
       case GL_TEXTURE_BINDING_EXTERNAL_OES:
           if (!context->getExtensions().eglStreamConsumerExternal)
           {
-              context->recordError(
+              context->handleError(
                   Error(GL_INVALID_ENUM, "NV_EGL_stream_consumer_external extension not enabled"));
               return false;
           }
@@ -1545,14 +1546,14 @@ bool ValidateStateQuery(gl::Context *context, GLenum pname, GLenum *nativeType,
             ASSERT(framebuffer);
             if (framebuffer->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
 
             const FramebufferAttachment *attachment = framebuffer->getReadColorbuffer();
             if (!attachment)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
         }
@@ -1588,39 +1589,39 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
 {
     if (level < 0 || xoffset < 0 || yoffset < 0 || zoffset < 0 || width < 0 || height < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (border != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (!ValidMipLevel(context, target, level))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     const gl::Framebuffer *framebuffer = context->getState().getReadFramebuffer();
     if (framebuffer->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     const auto &state = context->getState();
     if (state.getReadFramebuffer()->id() != 0 && framebuffer->getSamples(context->getData()) != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1651,7 +1652,7 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
         break;
 
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1659,13 +1660,13 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
         state.getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (texture->getImmutableFormat() && !isSubImage)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1673,13 +1674,13 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
 
     if (formatInfo.depthBits > 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (formatInfo.compressed && !ValidCompressedImageSize(context, internalformat, width, height))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1689,7 +1690,7 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
             static_cast<size_t>(zoffset) >= texture->getDepth(target, level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -1697,20 +1698,20 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
     {
         if (IsCubeMapTextureTarget(target) && width != height)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
 
         if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
         int maxLevelDimension = (maxDimension >> level);
         if (static_cast<int>(width) > maxLevelDimension || static_cast<int>(height) > maxLevelDimension)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -1735,13 +1736,13 @@ static bool ValidateDrawBase(ValidationContext *context,
       case GL_TRIANGLE_FAN:
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (count < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1750,7 +1751,7 @@ static bool ValidateDrawBase(ValidationContext *context,
     // Check for mapped buffers
     if (state.hasMappedBuffer(GL_ARRAY_BUFFER))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1772,7 +1773,7 @@ static bool ValidateDrawBase(ValidationContext *context,
             ERR(
                 "This ANGLE implementation does not support separate front/back stencil "
                 "writemasks, reference values, or stencil mask values.");
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -1780,20 +1781,20 @@ static bool ValidateDrawBase(ValidationContext *context,
     const gl::Framebuffer *fbo = state.getDrawFramebuffer();
     if (!fbo || fbo->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     gl::Program *program = state.getProgram();
     if (!program)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (!program->validateSamplers(NULL, context->getCaps()))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1808,7 +1809,9 @@ static bool ValidateDrawBase(ValidationContext *context,
         if (uniformBuffer.get() == nullptr)
         {
             // undefined behaviour
-            context->recordError(Error(GL_INVALID_OPERATION, "It is undefined behaviour to have a used but unbound uniform buffer."));
+            context->handleError(
+                Error(GL_INVALID_OPERATION,
+                      "It is undefined behaviour to have a used but unbound uniform buffer."));
             return false;
         }
 
@@ -1822,7 +1825,9 @@ static bool ValidateDrawBase(ValidationContext *context,
         if (uniformBufferSize < uniformBlock.dataSize)
         {
             // undefined behaviour
-            context->recordError(Error(GL_INVALID_OPERATION, "It is undefined behaviour to use a uniform buffer that is too small."));
+            context->handleError(
+                Error(GL_INVALID_OPERATION,
+                      "It is undefined behaviour to use a uniform buffer that is too small."));
             return false;
         }
     }
@@ -1835,7 +1840,7 @@ bool ValidateDrawArrays(Context *context, GLenum mode, GLint first, GLsizei coun
 {
     if (first < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1847,7 +1852,7 @@ bool ValidateDrawArrays(Context *context, GLenum mode, GLint first, GLsizei coun
         // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
         // that does not match the current transform feedback object's draw mode (if transform feedback
         // is active), (3.0.2, section 2.14, pg 86)
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1868,7 +1873,7 @@ bool ValidateDrawArraysInstanced(Context *context, GLenum mode, GLint first, GLs
 {
     if (primcount < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1898,8 +1903,9 @@ static bool ValidateDrawInstancedANGLE(Context *context)
         }
     }
 
-    context->recordError(Error(GL_INVALID_OPERATION, "ANGLE_instanced_arrays requires that at least one active attribute"
-                                                     "has a divisor of zero."));
+    context->handleError(Error(GL_INVALID_OPERATION,
+                               "ANGLE_instanced_arrays requires that at least one active attribute"
+                               "has a divisor of zero."));
     return false;
 }
 
@@ -1929,12 +1935,12 @@ bool ValidateDrawElements(ValidationContext *context,
       case GL_UNSIGNED_INT:
           if (context->getClientVersion() < 3 && !context->getExtensions().elementIndexUint)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1945,14 +1951,14 @@ bool ValidateDrawElements(ValidationContext *context,
     {
         // It is an invalid operation to call DrawElements, DrawRangeElements or DrawElementsInstanced
         // while transform feedback is active, (3.0.2, section 2.14, pg 86)
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     // Check for mapped buffers
     if (state.hasMappedBuffer(GL_ELEMENT_ARRAY_BUFFER))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1960,7 +1966,7 @@ bool ValidateDrawElements(ValidationContext *context,
     gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
     if (!indices && !elementArrayBuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1975,21 +1981,21 @@ bool ValidateDrawElements(ValidationContext *context,
         if (static_cast<GLuint>(count) > (std::numeric_limits<GLuint>::max() / typeInfo.bytes) ||
             byteCount > static_cast<GLint64>(std::numeric_limits<GLuint>::max()))
         {
-            context->recordError(Error(GL_OUT_OF_MEMORY));
+            context->handleError(Error(GL_OUT_OF_MEMORY));
             return false;
         }
 
         // Check for reading past the end of the bound buffer object
         if (byteCount > elementArrayBuffer->getSize())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
     else if (!indices)
     {
         // Catch this programming error here
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2009,7 +2015,7 @@ bool ValidateDrawElements(ValidationContext *context,
                                               state.isPrimitiveRestartEnabled(), indexRangeOut);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return false;
         }
     }
@@ -2023,7 +2029,7 @@ bool ValidateDrawElements(ValidationContext *context,
     // return an error if possible here.
     if (static_cast<GLuint64>(indexRangeOut->end) >= context->getCaps().maxElementIndex)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, g_ExceedsMaxElementErrorMessage));
+        context->handleError(Error(GL_INVALID_OPERATION, g_ExceedsMaxElementErrorMessage));
         return false;
     }
 
@@ -2046,7 +2052,7 @@ bool ValidateDrawElementsInstanced(Context *context,
 {
     if (primcount < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -2080,7 +2086,7 @@ bool ValidateFramebufferTextureBase(Context *context, GLenum target, GLenum atta
 {
     if (!ValidFramebufferTarget(target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -2095,13 +2101,13 @@ bool ValidateFramebufferTextureBase(Context *context, GLenum target, GLenum atta
 
         if (tex == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
         if (level < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -2111,7 +2117,8 @@ bool ValidateFramebufferTextureBase(Context *context, GLenum target, GLenum atta
 
     if (framebuffer->id() == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Cannot change default FBO's attachments"));
+        context->handleError(
+            Error(GL_INVALID_OPERATION, "Cannot change default FBO's attachments"));
         return false;
     }
 
@@ -2124,7 +2131,7 @@ bool ValidateFramebufferTexture2D(Context *context, GLenum target, GLenum attach
     // Attachments are required to be bound to level 0 without ES3 or the GL_OES_fbo_render_mipmap extension
     if (context->getClientVersion() < 3 && !context->getExtensions().fboRenderMipmap && level != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -2146,12 +2153,12 @@ bool ValidateFramebufferTexture2D(Context *context, GLenum target, GLenum attach
             {
                 if (level > gl::log2(caps.max2DTextureSize))
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
                 if (tex->getTarget() != GL_TEXTURE_2D)
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
             }
@@ -2166,26 +2173,26 @@ bool ValidateFramebufferTexture2D(Context *context, GLenum target, GLenum attach
             {
                 if (level > gl::log2(caps.maxCubeMapTextureSize))
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
                 if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
         const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(tex->getInternalFormat(textarget, level));
         if (internalFormatInfo.compressed)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -2197,7 +2204,7 @@ bool ValidateGetUniformBase(Context *context, GLuint program, GLint location)
 {
     if (program == 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -2209,13 +2216,13 @@ bool ValidateGetUniformBase(Context *context, GLuint program, GLint location)
 
     if (!programObject || !programObject->isLinked())
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (!programObject->isValidUniformLocation(location))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2247,7 +2254,7 @@ static bool ValidateSizedGetUniform(Context *context, GLuint program, GLint loca
     size_t requiredBytes = VariableExternalSize(uniform.type);
     if (static_cast<size_t>(bufSize) < requiredBytes)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2269,7 +2276,7 @@ bool ValidateDiscardFramebufferBase(Context *context, GLenum target, GLsizei num
 {
     if (numAttachments < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "numAttachments must not be less than zero"));
+        context->handleError(Error(GL_INVALID_VALUE, "numAttachments must not be less than zero"));
         return false;
     }
 
@@ -2279,14 +2286,16 @@ bool ValidateDiscardFramebufferBase(Context *context, GLenum target, GLsizei num
         {
             if (defaultFramebuffer)
             {
-                context->recordError(Error(GL_INVALID_ENUM, "Invalid attachment when the default framebuffer is bound"));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "Invalid attachment when the default framebuffer is bound"));
                 return false;
             }
 
             if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getCaps().maxColorAttachments)
             {
-                context->recordError(Error(GL_INVALID_OPERATION,
-                                           "Requested color attachment is greater than the maximum supported color attachments"));
+                context->handleError(Error(GL_INVALID_OPERATION,
+                                           "Requested color attachment is greater than the maximum "
+                                           "supported color attachments"));
                 return false;
             }
         }
@@ -2299,7 +2308,9 @@ bool ValidateDiscardFramebufferBase(Context *context, GLenum target, GLsizei num
               case GL_DEPTH_STENCIL_ATTACHMENT:
                 if (defaultFramebuffer)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM, "Invalid attachment when the default framebuffer is bound"));
+                    context->handleError(
+                        Error(GL_INVALID_ENUM,
+                              "Invalid attachment when the default framebuffer is bound"));
                     return false;
                 }
                 break;
@@ -2308,12 +2319,14 @@ bool ValidateDiscardFramebufferBase(Context *context, GLenum target, GLsizei num
               case GL_STENCIL:
                 if (!defaultFramebuffer)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM, "Invalid attachment when the default framebuffer is not bound"));
+                    context->handleError(
+                        Error(GL_INVALID_ENUM,
+                              "Invalid attachment when the default framebuffer is not bound"));
                     return false;
                 }
                 break;
               default:
-                context->recordError(Error(GL_INVALID_ENUM, "Invalid attachment"));
+                  context->handleError(Error(GL_INVALID_ENUM, "Invalid attachment"));
                 return false;
             }
         }
@@ -2363,7 +2376,7 @@ bool ValidateEGLImageTargetTexture2DOES(Context *context,
 {
     if (!context->getExtensions().eglImage && !context->getExtensions().eglImageExternal)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2373,19 +2386,19 @@ bool ValidateEGLImageTargetTexture2DOES(Context *context,
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "invalid texture target."));
+            context->handleError(Error(GL_INVALID_ENUM, "invalid texture target."));
             return false;
     }
 
     if (!display->isValidImage(image))
     {
-        context->recordError(Error(GL_INVALID_VALUE, "EGL image is not valid."));
+        context->handleError(Error(GL_INVALID_VALUE, "EGL image is not valid."));
         return false;
     }
 
     if (image->getSamples() > 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION,
+        context->handleError(Error(GL_INVALID_OPERATION,
                                    "cannot create a 2D texture from a multisampled EGL image."));
         return false;
     }
@@ -2393,7 +2406,7 @@ bool ValidateEGLImageTargetTexture2DOES(Context *context,
     const TextureCaps &textureCaps = context->getTextureCaps().get(image->getInternalFormat());
     if (!textureCaps.texturable)
     {
-        context->recordError(Error(GL_INVALID_OPERATION,
+        context->handleError(Error(GL_INVALID_OPERATION,
                                    "EGL image internal format is not supported as a texture."));
         return false;
     }
@@ -2408,7 +2421,7 @@ bool ValidateEGLImageTargetRenderbufferStorageOES(Context *context,
 {
     if (!context->getExtensions().eglImage)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2418,20 +2431,20 @@ bool ValidateEGLImageTargetRenderbufferStorageOES(Context *context,
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "invalid renderbuffer target."));
+            context->handleError(Error(GL_INVALID_ENUM, "invalid renderbuffer target."));
             return false;
     }
 
     if (!display->isValidImage(image))
     {
-        context->recordError(Error(GL_INVALID_VALUE, "EGL image is not valid."));
+        context->handleError(Error(GL_INVALID_VALUE, "EGL image is not valid."));
         return false;
     }
 
     const TextureCaps &textureCaps = context->getTextureCaps().get(image->getInternalFormat());
     if (!textureCaps.renderable)
     {
-        context->recordError(Error(
+        context->handleError(Error(
             GL_INVALID_OPERATION, "EGL image internal format is not supported as a renderbuffer."));
         return false;
     }
@@ -2445,7 +2458,7 @@ bool ValidateBindVertexArrayBase(Context *context, GLuint array)
     {
         // The default VAO should always exist
         ASSERT(array != 0);
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2457,7 +2470,7 @@ bool ValidateLinkProgram(Context *context, GLuint program)
     if (context->hasActiveTransformFeedback(program))
     {
         // ES 3.0.4 section 2.15 page 91
-        context->recordError(Error(GL_INVALID_OPERATION,
+        context->handleError(Error(GL_INVALID_OPERATION,
                                    "Cannot link program while program is associated with an active "
                                    "transform feedback object."));
         return false;
@@ -2481,14 +2494,14 @@ bool ValidateProgramBinaryBase(Context *context,
     if (std::find(programBinaryFormats.begin(), programBinaryFormats.end(), binaryFormat) ==
         programBinaryFormats.end())
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Program binary format is not valid."));
+        context->handleError(Error(GL_INVALID_ENUM, "Program binary format is not valid."));
         return false;
     }
 
     if (context->hasActiveTransformFeedback(program))
     {
         // ES 3.0.4 section 2.15 page 91
-        context->recordError(Error(GL_INVALID_OPERATION,
+        context->handleError(Error(GL_INVALID_OPERATION,
                                    "Cannot change program binary while program is associated with "
                                    "an active transform feedback object."));
         return false;
@@ -2512,7 +2525,7 @@ bool ValidateGetProgramBinaryBase(Context *context,
 
     if (!programObject->isLinked())
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Program is not linked."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Program is not linked."));
         return false;
     }
 
@@ -2529,27 +2542,27 @@ bool ValidateUseProgram(Context *context, GLuint program)
             // ES 3.1.0 section 7.3 page 72
             if (context->getShader(program))
             {
-                context->recordError(
+                context->handleError(
                     Error(GL_INVALID_OPERATION,
                           "Attempted to use a single shader instead of a shader program."));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_VALUE, "Program invalid."));
+                context->handleError(Error(GL_INVALID_VALUE, "Program invalid."));
                 return false;
             }
         }
         if (!programObject->isLinked())
         {
-            context->recordError(Error(GL_INVALID_OPERATION, "Program not linked."));
+            context->handleError(Error(GL_INVALID_OPERATION, "Program not linked."));
             return false;
         }
     }
     if (context->getState().isTransformFeedbackActiveUnpaused())
     {
         // ES 3.0.4 section 2.15 page 91
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION,
                   "Cannot change active program while transform feedback is unpaused."));
         return false;
@@ -2588,7 +2601,7 @@ bool ValidateFramebufferRenderbuffer(Context *context,
     if (!ValidFramebufferTarget(target) ||
         (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -2601,7 +2614,7 @@ bool ValidateDrawBuffersBase(ValidationContext *context, GLsizei n, const GLenum
     // INVALID_VALUE is generated if n is negative or greater than value of MAX_DRAW_BUFFERS
     if (n < 0 || static_cast<GLuint>(n) > context->getCaps().maxDrawBuffers)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "n must be non-negative and no greater than MAX_DRAW_BUFFERS"));
         return false;
     }
@@ -2626,12 +2639,12 @@ bool ValidateDrawBuffersBase(ValidationContext *context, GLsizei n, const GLenum
             // was changed to GL_INVALID_ENUM in 3.1, which dEQP also expects.
             // 3.1 is still a bit ambiguous about the error, but future specs are
             // expected to clarify that GL_INVALID_ENUM is the correct error.
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid buffer value"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer value"));
             return false;
         }
         else if (bufs[colorAttachment] >= maxColorAttachment)
         {
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION, "Buffer value is greater than MAX_DRAW_BUFFERS"));
             return false;
         }
@@ -2640,7 +2653,7 @@ bool ValidateDrawBuffersBase(ValidationContext *context, GLsizei n, const GLenum
         {
             // INVALID_OPERATION-GL is bound to buffer and ith argument
             // is not COLOR_ATTACHMENTi or NONE
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION, "Ith value does not match COLOR_ATTACHMENTi or NONE"));
             return false;
         }
@@ -2652,14 +2665,14 @@ bool ValidateDrawBuffersBase(ValidationContext *context, GLsizei n, const GLenum
     {
         if (n != 1)
         {
-            context->recordError(Error(GL_INVALID_OPERATION,
+            context->handleError(Error(GL_INVALID_OPERATION,
                                        "n must be 1 when GL is bound to the default framebuffer"));
             return false;
         }
 
         if (bufs[0] != GL_NONE && bufs[0] != GL_BACK)
         {
-            context->recordError(Error(
+            context->handleError(Error(
                 GL_INVALID_OPERATION,
                 "Only NONE or BACK are valid values when drawing to the default framebuffer"));
             return false;
@@ -2693,13 +2706,13 @@ bool ValidateGetBufferPointervBase(Context *context, GLenum target, GLenum pname
 {
     if (!ValidBufferTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Buffer target not valid: 0x%X", target));
+        context->handleError(Error(GL_INVALID_ENUM, "Buffer target not valid: 0x%X", target));
         return false;
     }
 
     if (pname != GL_BUFFER_MAP_POINTER)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "pname not valid: 0x%X", pname));
+        context->handleError(Error(GL_INVALID_ENUM, "pname not valid: 0x%X", pname));
         return false;
     }
 
@@ -2710,7 +2723,7 @@ bool ValidateGetBufferPointervBase(Context *context, GLenum target, GLenum pname
     // GLES 3.1 section 6.6 explicitly specifies this error.
     if (!buffer)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Can not get pointer for reserved buffer name zero."));
         return false;
     }
@@ -2722,7 +2735,7 @@ bool ValidateUnmapBufferBase(Context *context, GLenum target)
 {
     if (!ValidBufferTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
         return false;
     }
 
@@ -2730,7 +2743,7 @@ bool ValidateUnmapBufferBase(Context *context, GLenum target)
 
     if (buffer == nullptr || !buffer->isMapped())
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Buffer not mapped."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Buffer not mapped."));
         return false;
     }
 
@@ -2745,13 +2758,13 @@ bool ValidateMapBufferRangeBase(Context *context,
 {
     if (!ValidBufferTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
         return false;
     }
 
     if (offset < 0 || length < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "Invalid offset or length."));
+        context->handleError(Error(GL_INVALID_VALUE, "Invalid offset or length."));
         return false;
     }
 
@@ -2759,7 +2772,7 @@ bool ValidateMapBufferRangeBase(Context *context,
 
     if (!buffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero."));
         return false;
     }
 
@@ -2770,7 +2783,7 @@ bool ValidateMapBufferRangeBase(Context *context,
     if (!rx::IsUnsignedAdditionSafe(offsetSize, lengthSize) ||
         offsetSize + lengthSize > static_cast<size_t>(buffer->getSize()))
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Mapped range does not fit into buffer dimensions."));
         return false;
     }
@@ -2782,26 +2795,26 @@ bool ValidateMapBufferRangeBase(Context *context,
 
     if (access & ~(allAccessBits))
     {
-        context->recordError(Error(GL_INVALID_VALUE, "Invalid access bits: 0x%X.", access));
+        context->handleError(Error(GL_INVALID_VALUE, "Invalid access bits: 0x%X.", access));
         return false;
     }
 
     if (length == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Buffer mapping length is zero."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Buffer mapping length is zero."));
         return false;
     }
 
     if (buffer->isMapped())
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Buffer is already mapped."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Buffer is already mapped."));
         return false;
     }
 
     // Check for invalid bit combinations
     if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Need to map buffer for either reading or writing."));
         return false;
     }
@@ -2811,7 +2824,7 @@ bool ValidateMapBufferRangeBase(Context *context,
 
     if ((access & GL_MAP_READ_BIT) != 0 && (access & writeOnlyBits) != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION,
+        context->handleError(Error(GL_INVALID_OPERATION,
                                    "Invalid access bits when mapping buffer for reading: 0x%X.",
                                    access));
         return false;
@@ -2819,7 +2832,7 @@ bool ValidateMapBufferRangeBase(Context *context,
 
     if ((access & GL_MAP_WRITE_BIT) == 0 && (access & GL_MAP_FLUSH_EXPLICIT_BIT) != 0)
     {
-        context->recordError(Error(
+        context->handleError(Error(
             GL_INVALID_OPERATION,
             "The explicit flushing bit may only be set if the buffer is mapped for writing."));
         return false;
@@ -2834,13 +2847,13 @@ bool ValidateFlushMappedBufferRangeBase(Context *context,
 {
     if (offset < 0 || length < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "Invalid offset/length parameters."));
+        context->handleError(Error(GL_INVALID_VALUE, "Invalid offset/length parameters."));
         return false;
     }
 
     if (!ValidBufferTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
         return false;
     }
 
@@ -2848,13 +2861,13 @@ bool ValidateFlushMappedBufferRangeBase(Context *context,
 
     if (buffer == nullptr)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Attempted to flush buffer object zero."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Attempted to flush buffer object zero."));
         return false;
     }
 
     if (!buffer->isMapped() || (buffer->getAccessFlags() & GL_MAP_FLUSH_EXPLICIT_BIT) == 0)
     {
-        context->recordError(Error(
+        context->handleError(Error(
             GL_INVALID_OPERATION, "Attempted to flush a buffer not mapped for explicit flushing."));
         return false;
     }
@@ -2866,7 +2879,7 @@ bool ValidateFlushMappedBufferRangeBase(Context *context,
     if (!rx::IsUnsignedAdditionSafe(offsetSize, lengthSize) ||
         offsetSize + lengthSize > static_cast<size_t>(buffer->getMapLength()))
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Flushed range does not fit into buffer mapping dimensions."));
         return false;
     }
@@ -2918,7 +2931,7 @@ bool ValidateGenOrDelete(Context *context, GLint n)
 {
     if (n < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "n < 0"));
+        context->handleError(Error(GL_INVALID_VALUE, "n < 0"));
         return false;
     }
     return true;
diff --git a/src/libANGLE/validationES2.cpp b/src/libANGLE/validationES2.cpp
index 120cc7322..454364c0e 100644
--- a/src/libANGLE/validationES2.cpp
+++ b/src/libANGLE/validationES2.cpp
@@ -65,13 +65,13 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (!ValidImageSizeParameters(context, target, level, width, height, 1, isSubImage))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -79,13 +79,13 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         std::numeric_limits<GLsizei>::max() - xoffset < width ||
         std::numeric_limits<GLsizei>::max() - yoffset < height)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (!isSubImage && !isCompressed && internalformat != format)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -96,7 +96,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) ||
             static_cast<GLuint>(height) > (caps.max2DTextureSize >> level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -104,27 +104,27 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
     {
         if (!isSubImage && width != height)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
 
         if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level) ||
             static_cast<GLuint>(height) > (caps.maxCubeMapTextureSize >> level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
     else
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -134,7 +134,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         {
             if (gl::GetSizedInternalFormat(format, type) != texture->getInternalFormat(target, level))
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
         }
@@ -142,7 +142,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -150,7 +150,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
     {
         if (texture->getImmutableFormat())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -158,7 +158,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
     // Verify zero border
     if (border != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -172,47 +172,47 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
             if (!context->getExtensions().textureCompressionDXT1)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
             if (!context->getExtensions().textureCompressionDXT1)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             if (!context->getExtensions().textureCompressionDXT5)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_OES:
             if (!context->getExtensions().compressedETC1RGB8Texture)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
               if (!context->getExtensions().lossyETCDecode)
               {
-                  context->recordError(
+                  context->handleError(
                       Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported"));
                   return false;
               }
               break;
           default:
-              context->recordError(Error(
+              context->handleError(Error(
                   GL_INVALID_ENUM, "internalformat is not a supported compressed internal format"));
               return false;
         }
         if (!ValidCompressedImageSize(context, actualInternalFormat, width, height))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -232,7 +232,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_FLOAT:
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
@@ -251,7 +251,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
             }
             break;
@@ -259,7 +259,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_RG:
               if (!context->getExtensions().textureRG)
               {
-                  context->recordError(Error(GL_INVALID_ENUM));
+                  context->handleError(Error(GL_INVALID_ENUM));
                   return false;
               }
               switch (type)
@@ -269,7 +269,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
                 case GL_HALF_FLOAT_OES:
                   break;
                 default:
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -282,7 +282,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -296,7 +296,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -306,7 +306,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_UNSIGNED_BYTE:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -314,7 +314,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_SRGB_ALPHA_EXT:
             if (!context->getExtensions().sRGB)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             switch (type)
@@ -322,7 +322,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_UNSIGNED_BYTE:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -338,7 +338,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_UNSIGNED_INT:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -348,12 +348,12 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
               case GL_UNSIGNED_INT_24_8_OES:
                 break;
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
@@ -363,62 +363,62 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
             if (context->getExtensions().textureCompressionDXT1)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
             if (context->getExtensions().textureCompressionDXT3)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             if (context->getExtensions().textureCompressionDXT5)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_OES:
             if (context->getExtensions().compressedETC1RGB8Texture)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
               if (context->getExtensions().lossyETCDecode)
               {
-                  context->recordError(
+                  context->handleError(
                       Error(GL_INVALID_OPERATION,
                             "ETC1_RGB8_LOSSY_DECODE_ANGLE can't work with this type."));
                   return false;
               }
               else
               {
-                  context->recordError(
+                  context->handleError(
                       Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
                   return false;
               }
@@ -427,19 +427,19 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
           case GL_DEPTH_STENCIL_OES:
             if (!context->getExtensions().depthTextures)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             if (target != GL_TEXTURE_2D)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             // OES_depth_texture supports loading depth data and multiple levels,
             // but ANGLE_depth_texture does not
             if (pixels != NULL || level != 0)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -451,7 +451,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         {
             if (!context->getExtensions().textureFloat)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
         }
@@ -459,7 +459,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         {
             if (!context->getExtensions().textureHalfFloat)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
         }
@@ -485,7 +485,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
 
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target"));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target"));
         return false;
     }
 
@@ -511,7 +511,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGB5_A1 &&
                 colorbufferFormat != GL_RGBA8_OES)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -524,7 +524,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGB5_A1 &&
                   colorbufferFormat != GL_RGBA8_OES)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -541,7 +541,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGB32F &&
                   colorbufferFormat != GL_RGBA32F)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -556,7 +556,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGB32F &&
                   colorbufferFormat != GL_RGBA32F)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -569,7 +569,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGB32F &&
                 colorbufferFormat != GL_RGBA32F)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -580,7 +580,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGBA8_OES &&
                 colorbufferFormat != GL_RGBA32F)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -590,21 +590,21 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
           case GL_ETC1_RGB8_OES:
           case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
-            context->recordError(Error(GL_INVALID_OPERATION));
+              context->handleError(Error(GL_INVALID_OPERATION));
             return false;
           case GL_DEPTH_COMPONENT:
           case GL_DEPTH_STENCIL_OES:
-            context->recordError(Error(GL_INVALID_OPERATION));
+              context->handleError(Error(GL_INVALID_OPERATION));
             return false;
           default:
-            context->recordError(Error(GL_INVALID_OPERATION));
+              context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
         if (internalFormatInfo.type == GL_FLOAT &&
             !context->getExtensions().textureFloat)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -620,7 +620,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGBA8_OES &&
                 colorbufferFormat != GL_BGR5_A1_ANGLEX)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -635,7 +635,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGBA8_OES &&
                   colorbufferFormat != GL_BGR5_A1_ANGLEX)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -650,7 +650,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGBA8_OES &&
                   colorbufferFormat != GL_BGR5_A1_ANGLEX)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -664,7 +664,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                   colorbufferFormat != GL_RGBA8_OES &&
                   colorbufferFormat != GL_BGR5_A1_ANGLEX)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                   return false;
               }
               break;
@@ -677,7 +677,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGBA8_OES &&
                 colorbufferFormat != GL_BGR5_A1_ANGLEX)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -689,7 +689,7 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
                 colorbufferFormat != GL_RGBA8_OES &&
                 colorbufferFormat != GL_BGR5_A1_ANGLEX)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             break;
@@ -697,61 +697,61 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
           case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
             if (context->getExtensions().textureCompressionDXT1)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
             if (context->getExtensions().textureCompressionDXT3)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             if (context->getExtensions().textureCompressionDXT5)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_OES:
             if (context->getExtensions().compressedETC1RGB8Texture)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
             break;
           case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
               if (context->getExtensions().lossyETCDecode)
               {
-                  context->recordError(Error(GL_INVALID_OPERATION,
+                  context->handleError(Error(GL_INVALID_OPERATION,
                                              "ETC1_RGB8_LOSSY_DECODE_ANGLE can't be copied to."));
                   return false;
               }
               else
               {
-                  context->recordError(
+                  context->handleError(
                       Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
                   return false;
               }
@@ -763,16 +763,16 @@ bool ValidateES2CopyTexImageParameters(ValidationContext *context,
           case GL_DEPTH24_STENCIL8_OES:
             if (context->getExtensions().depthTextures)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return false;
             }
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
     }
@@ -786,32 +786,32 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
 {
     if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (width < 1 || height < 1 || levels < 1)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (target == GL_TEXTURE_CUBE_MAP && width != height)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
     if (formatInfo.format == GL_NONE || formatInfo.type == GL_NONE)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -823,7 +823,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
         if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
             static_cast<GLuint>(height) > caps.max2DTextureSize)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
@@ -831,12 +831,12 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
         if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize ||
             static_cast<GLuint>(height) > caps.maxCubeMapTextureSize)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -844,7 +844,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
     {
         if (!gl::isPow2(width) || !gl::isPow2(height))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -855,35 +855,35 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
         if (!context->getExtensions().textureCompressionDXT1)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
       case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
         if (!context->getExtensions().textureCompressionDXT3)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
       case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
         if (!context->getExtensions().textureCompressionDXT5)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
       case GL_ETC1_RGB8_OES:
         if (!context->getExtensions().compressedETC1RGB8Texture)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
       case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
           if (!context->getExtensions().lossyETCDecode)
           {
-              context->recordError(
+              context->handleError(
                   Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
               return false;
           }
@@ -895,7 +895,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
       case GL_LUMINANCE_ALPHA32F_EXT:
         if (!context->getExtensions().textureFloat)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -906,7 +906,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
       case GL_LUMINANCE_ALPHA16F_EXT:
         if (!context->getExtensions().textureHalfFloat)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -918,7 +918,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
       case GL_RG32F_EXT:
         if (!context->getExtensions().textureRG)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         break;
@@ -927,18 +927,18 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
       case GL_DEPTH24_STENCIL8_OES:
         if (!context->getExtensions().depthTextures)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
         if (target != GL_TEXTURE_2D)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
         // ANGLE_depth_texture only supports 1-level textures
         if (levels != 1)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
         break;
@@ -949,13 +949,13 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
     gl::Texture *texture = context->getTargetTexture(target);
     if (!texture || texture->id() == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (texture->getImmutableFormat())
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1013,7 +1013,7 @@ bool ValidateDiscardFramebufferEXT(Context *context, GLenum target, GLsizei numA
 {
     if (!context->getExtensions().discardFramebuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1025,7 +1025,7 @@ bool ValidateDiscardFramebufferEXT(Context *context, GLenum target, GLsizei numA
         defaultFramebuffer = (context->getState().getTargetFramebuffer(GL_FRAMEBUFFER)->id() == 0);
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid framebuffer target"));
+          context->handleError(Error(GL_INVALID_ENUM, "Invalid framebuffer target"));
         return false;
     }
 
@@ -1036,7 +1036,7 @@ bool ValidateBindVertexArrayOES(Context *context, GLuint array)
 {
     if (!context->getExtensions().vertexArrayObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1047,7 +1047,7 @@ bool ValidateDeleteVertexArraysOES(Context *context, GLsizei n)
 {
     if (!context->getExtensions().vertexArrayObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1058,7 +1058,7 @@ bool ValidateGenVertexArraysOES(Context *context, GLsizei n)
 {
     if (!context->getExtensions().vertexArrayObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1069,7 +1069,7 @@ bool ValidateIsVertexArrayOES(Context *context)
 {
     if (!context->getExtensions().vertexArrayObject)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1084,7 +1084,7 @@ bool ValidateProgramBinaryOES(Context *context,
 {
     if (!context->getExtensions().getProgramBinary)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1100,7 +1100,7 @@ bool ValidateGetProgramBinaryOES(Context *context,
 {
     if (!context->getExtensions().getProgramBinary)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1172,25 +1172,25 @@ bool ValidateDebugMessageControlKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     if (!ValidDebugSource(source, false) && source != GL_DONT_CARE)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug source."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
         return false;
     }
 
     if (!ValidDebugType(type) && type != GL_DONT_CARE)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug type."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type."));
         return false;
     }
 
     if (!ValidDebugSeverity(severity) && severity != GL_DONT_CARE)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
         return false;
     }
 
@@ -1198,7 +1198,7 @@ bool ValidateDebugMessageControlKHR(Context *context,
     {
         if (source == GL_DONT_CARE || type == GL_DONT_CARE)
         {
-            context->recordError(Error(
+            context->handleError(Error(
                 GL_INVALID_OPERATION,
                 "If count is greater than zero, source and severity cannot be GL_DONT_CARE."));
             return false;
@@ -1206,7 +1206,7 @@ bool ValidateDebugMessageControlKHR(Context *context,
 
         if (severity != GL_DONT_CARE)
         {
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION,
                       "If count is greater than zero, severity must be GL_DONT_CARE."));
             return false;
@@ -1226,7 +1226,7 @@ bool ValidateDebugMessageInsertKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1239,26 +1239,26 @@ bool ValidateDebugMessageInsertKHR(Context *context,
 
     if (!ValidDebugSeverity(severity))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
         return false;
     }
 
     if (!ValidDebugType(type))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug type."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type."));
         return false;
     }
 
     if (!ValidDebugSource(source, true))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug source."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
         return false;
     }
 
     size_t messageLength = (length < 0) ? strlen(buf) : length;
     if (messageLength > context->getExtensions().maxDebugMessageLength)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH."));
         return false;
     }
@@ -1272,7 +1272,7 @@ bool ValidateDebugMessageCallbackKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1291,13 +1291,13 @@ bool ValidateGetDebugMessageLogKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     if (bufSize < 0 && messageLog != nullptr)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "bufSize must be positive if messageLog is not null."));
         return false;
     }
@@ -1313,20 +1313,20 @@ bool ValidatePushDebugGroupKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     if (!ValidDebugSource(source, true))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid debug source."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
         return false;
     }
 
     size_t messageLength = (length < 0) ? strlen(message) : length;
     if (messageLength > context->getExtensions().maxDebugMessageLength)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH."));
         return false;
     }
@@ -1334,7 +1334,7 @@ bool ValidatePushDebugGroupKHR(Context *context,
     size_t currentStackSize = context->getState().getDebug().getGroupStackDepth();
     if (currentStackSize >= context->getExtensions().maxDebugGroupStackDepth)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_STACK_OVERFLOW,
                   "Cannot push more than GL_MAX_DEBUG_GROUP_STACK_DEPTH debug groups."));
         return false;
@@ -1347,14 +1347,14 @@ bool ValidatePopDebugGroupKHR(Context *context)
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     size_t currentStackSize = context->getState().getDebug().getGroupStackDepth();
     if (currentStackSize <= 1)
     {
-        context->recordError(Error(GL_STACK_UNDERFLOW, "Cannot pop the default debug group."));
+        context->handleError(Error(GL_STACK_UNDERFLOW, "Cannot pop the default debug group."));
         return false;
     }
 
@@ -1368,7 +1368,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_BUFFER:
             if (context->getBuffer(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid buffer."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid buffer."));
                 return false;
             }
             return true;
@@ -1376,7 +1376,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_SHADER:
             if (context->getShader(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid shader."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid shader."));
                 return false;
             }
             return true;
@@ -1384,7 +1384,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_PROGRAM:
             if (context->getProgram(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid program."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid program."));
                 return false;
             }
             return true;
@@ -1392,7 +1392,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_VERTEX_ARRAY:
             if (context->getVertexArray(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid vertex array."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid vertex array."));
                 return false;
             }
             return true;
@@ -1400,7 +1400,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_QUERY:
             if (context->getQuery(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid query."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid query."));
                 return false;
             }
             return true;
@@ -1408,7 +1408,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_TRANSFORM_FEEDBACK:
             if (context->getTransformFeedback(name) == nullptr)
             {
-                context->recordError(
+                context->handleError(
                     Error(GL_INVALID_VALUE, "name is not a valid transform feedback."));
                 return false;
             }
@@ -1417,7 +1417,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_SAMPLER:
             if (context->getSampler(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid sampler."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sampler."));
                 return false;
             }
             return true;
@@ -1425,7 +1425,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_TEXTURE:
             if (context->getTexture(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid texture."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid texture."));
                 return false;
             }
             return true;
@@ -1433,7 +1433,7 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_RENDERBUFFER:
             if (context->getRenderbuffer(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid renderbuffer."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid renderbuffer."));
                 return false;
             }
             return true;
@@ -1441,13 +1441,13 @@ static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier,
         case GL_FRAMEBUFFER:
             if (context->getFramebuffer(name) == nullptr)
             {
-                context->recordError(Error(GL_INVALID_VALUE, "name is not a valid framebuffer."));
+                context->handleError(Error(GL_INVALID_VALUE, "name is not a valid framebuffer."));
                 return false;
             }
             return true;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid identifier."));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid identifier."));
             return false;
     }
 
@@ -1462,7 +1462,7 @@ bool ValidateObjectLabelKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1474,7 +1474,7 @@ bool ValidateObjectLabelKHR(Context *context,
     size_t labelLength = (length < 0) ? strlen(label) : length;
     if (labelLength > context->getExtensions().maxLabelLength)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Label length is larger than GL_MAX_LABEL_LENGTH."));
         return false;
     }
@@ -1491,13 +1491,13 @@ bool ValidateGetObjectLabelKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
+        context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
         return false;
     }
 
@@ -1514,7 +1514,7 @@ static bool ValidateObjectPtrName(Context *context, const void *ptr)
 {
     if (context->getFenceSync(reinterpret_cast<GLsync>(const_cast<void *>(ptr))) == nullptr)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "name is not a valid sync."));
+        context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sync."));
         return false;
     }
 
@@ -1528,7 +1528,7 @@ bool ValidateObjectPtrLabelKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1540,7 +1540,7 @@ bool ValidateObjectPtrLabelKHR(Context *context,
     size_t labelLength = (length < 0) ? strlen(label) : length;
     if (labelLength > context->getExtensions().maxLabelLength)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_VALUE, "Label length is larger than GL_MAX_LABEL_LENGTH."));
         return false;
     }
@@ -1556,13 +1556,13 @@ bool ValidateGetObjectPtrLabelKHR(Context *context,
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
+        context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
         return false;
     }
 
@@ -1579,7 +1579,7 @@ bool ValidateGetPointervKHR(Context *context, GLenum pname, void **params)
 {
     if (!context->getExtensions().debug)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
         return false;
     }
 
@@ -1591,7 +1591,7 @@ bool ValidateGetPointervKHR(Context *context, GLenum pname, void **params)
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid pname."));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid pname."));
             return false;
     }
 
@@ -1612,14 +1612,14 @@ bool ValidateBlitFramebufferANGLE(Context *context,
 {
     if (!context->getExtensions().framebufferBlit)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Blit extension not available."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Blit extension not available."));
         return false;
     }
 
     if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
     {
         // TODO(jmadill): Determine if this should be available on other implementations.
-        context->recordError(Error(
+        context->handleError(Error(
             GL_INVALID_OPERATION,
             "Scaling and flipping in BlitFramebufferANGLE not supported by this implementation."));
         return false;
@@ -1627,7 +1627,7 @@ bool ValidateBlitFramebufferANGLE(Context *context,
 
     if (filter == GL_LINEAR)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Linear blit not supported in this extension"));
+        context->handleError(Error(GL_INVALID_ENUM, "Linear blit not supported in this extension"));
         return false;
     }
 
@@ -1646,7 +1646,7 @@ bool ValidateBlitFramebufferANGLE(Context *context,
                 readColorAttachment->type() != GL_RENDERBUFFER &&
                 readColorAttachment->type() != GL_FRAMEBUFFER_DEFAULT)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
 
@@ -1662,14 +1662,14 @@ bool ValidateBlitFramebufferANGLE(Context *context,
                         attachment->type() != GL_RENDERBUFFER &&
                         attachment->type() != GL_FRAMEBUFFER_DEFAULT)
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return false;
                     }
 
                     // Return an error if the destination formats do not match
                     if (attachment->getInternalFormat() != readColorAttachment->getInternalFormat())
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return false;
                     }
                 }
@@ -1681,7 +1681,7 @@ bool ValidateBlitFramebufferANGLE(Context *context,
                 IsPartialBlit(context, readColorAttachment, drawColorAttachment, srcX0, srcY0,
                               srcX1, srcY1, dstX0, dstY0, dstX1, dstY1))
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
         }
@@ -1707,13 +1707,13 @@ bool ValidateBlitFramebufferANGLE(Context *context,
                     ERR(
                         "Only whole-buffer depth and stencil blits are supported by this "
                         "implementation.");
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
 
                 if (readBuffer->getSamples() != 0 || drawBuffer->getSamples() != 0)
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return false;
                 }
             }
@@ -1731,13 +1731,13 @@ bool ValidateClear(ValidationContext *context, GLbitfield mask)
 
     if (framebufferObject->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1748,7 +1748,7 @@ bool ValidateDrawBuffersEXT(ValidationContext *context, GLsizei n, const GLenum
 {
     if (!context->getExtensions().drawBuffers)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Extension not supported."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Extension not supported."));
         return false;
     }
 
@@ -1834,7 +1834,7 @@ bool ValidateCompressedTexImage2D(Context *context,
         static_cast<GLuint>(imageSize) !=
             formatInfo.computeBlockSize(GL_UNSIGNED_BYTE, width, height))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1876,7 +1876,7 @@ bool ValidateCompressedTexSubImage2D(Context *context,
         static_cast<GLuint>(imageSize) !=
             formatInfo.computeBlockSize(GL_UNSIGNED_BYTE, width, height))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1887,7 +1887,7 @@ bool ValidateGetBufferPointervOES(Context *context, GLenum target, GLenum pname,
 {
     if (!context->getExtensions().mapBuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
         return false;
     }
 
@@ -1898,13 +1898,13 @@ bool ValidateMapBufferOES(Context *context, GLenum target, GLenum access)
 {
     if (!context->getExtensions().mapBuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
         return false;
     }
 
     if (!ValidBufferTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
+        context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
         return false;
     }
 
@@ -1912,19 +1912,19 @@ bool ValidateMapBufferOES(Context *context, GLenum target, GLenum access)
 
     if (buffer == nullptr)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero."));
         return false;
     }
 
     if (access != GL_WRITE_ONLY_OES)
     {
-        context->recordError(Error(GL_INVALID_ENUM, "Non-write buffer mapping not supported."));
+        context->handleError(Error(GL_INVALID_ENUM, "Non-write buffer mapping not supported."));
         return false;
     }
 
     if (buffer->isMapped())
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Buffer is already mapped."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Buffer is already mapped."));
         return false;
     }
 
@@ -1935,7 +1935,7 @@ bool ValidateUnmapBufferOES(Context *context, GLenum target)
 {
     if (!context->getExtensions().mapBuffer)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
         return false;
     }
 
@@ -1950,7 +1950,7 @@ bool ValidateMapBufferRangeEXT(Context *context,
 {
     if (!context->getExtensions().mapBufferRange)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Map buffer range extension not available."));
         return false;
     }
@@ -1965,7 +1965,7 @@ bool ValidateFlushMappedBufferRangeEXT(Context *context,
 {
     if (!context->getExtensions().mapBufferRange)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Map buffer range extension not available."));
         return false;
     }
@@ -1978,7 +1978,7 @@ bool ValidateBindTexture(Context *context, GLenum target, GLuint texture)
     Texture *textureObject = context->getTexture(texture);
     if (textureObject && textureObject->getTarget() != target && texture != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Invalid texture"));
+        context->handleError(Error(GL_INVALID_OPERATION, "Invalid texture"));
         return false;
     }
 
@@ -1992,20 +1992,20 @@ bool ValidateBindTexture(Context *context, GLenum target, GLuint texture)
         case GL_TEXTURE_2D_ARRAY:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM, "GLES 3.0 disabled"));
+                context->handleError(Error(GL_INVALID_ENUM, "GLES 3.0 disabled"));
                 return false;
             }
             break;
         case GL_TEXTURE_EXTERNAL_OES:
             if (!context->getExtensions().eglStreamConsumerExternal)
             {
-                context->recordError(
+                context->handleError(
                     Error(GL_INVALID_ENUM, "External texture extension not enabled"));
                 return false;
             }
             break;
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid target"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid target"));
             return false;
     }
 
@@ -2019,7 +2019,7 @@ bool ValidateBindUniformLocationCHROMIUM(Context *context,
 {
     if (!context->getExtensions().bindUniformLocation)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "GL_CHROMIUM_bind_uniform_location is not available."));
         return false;
     }
@@ -2032,7 +2032,7 @@ bool ValidateBindUniformLocationCHROMIUM(Context *context,
 
     if (location < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "Location cannot be less than 0."));
+        context->handleError(Error(GL_INVALID_VALUE, "Location cannot be less than 0."));
         return false;
     }
 
@@ -2040,7 +2040,7 @@ bool ValidateBindUniformLocationCHROMIUM(Context *context,
     if (static_cast<size_t>(location) >=
         (caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4)
     {
-        context->recordError(Error(GL_INVALID_VALUE,
+        context->handleError(Error(GL_INVALID_VALUE,
                                    "Location must be less than (MAX_VERTEX_UNIFORM_VECTORS + "
                                    "MAX_FRAGMENT_UNIFORM_VECTORS) * 4"));
         return false;
@@ -2048,7 +2048,7 @@ bool ValidateBindUniformLocationCHROMIUM(Context *context,
 
     if (strncmp(name, "gl_", 3) == 0)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Name cannot start with the reserved \"gl_\" prefix."));
         return false;
     }
diff --git a/src/libANGLE/validationES3.cpp b/src/libANGLE/validationES3.cpp
index 5b99e2f89..690672d07 100644
--- a/src/libANGLE/validationES3.cpp
+++ b/src/libANGLE/validationES3.cpp
@@ -209,7 +209,7 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -243,7 +243,7 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
 
     if (!typeSupported || !formatSupported)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -255,7 +255,7 @@ static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum inter
 
     if (es3FormatSet.find(searchFormat) == es3FormatSet.end())
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -282,14 +282,14 @@ bool ValidateES3TexImageParametersBase(Context *context,
     // Validate image size
     if (!ValidImageSizeParameters(context, target, level, width, height, depth, isSubImage))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     // Verify zero border
     if (border != 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -298,7 +298,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
         std::numeric_limits<GLsizei>::max() - yoffset < height ||
         std::numeric_limits<GLsizei>::max() - zoffset < depth)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -310,7 +310,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
         if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) ||
             static_cast<GLuint>(height) > (caps.max2DTextureSize >> level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
@@ -323,13 +323,13 @@ bool ValidateES3TexImageParametersBase(Context *context,
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
         if (!isSubImage && width != height)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
 
         if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
@@ -339,7 +339,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
             static_cast<GLuint>(height) > (caps.max3DTextureSize >> level) ||
             static_cast<GLuint>(depth) > (caps.max3DTextureSize >> level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
@@ -349,26 +349,26 @@ bool ValidateES3TexImageParametersBase(Context *context,
             static_cast<GLuint>(height) > (caps.max2DTextureSize >> level) ||
             static_cast<GLuint>(depth) > caps.maxArrayTextureLayers)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
         break;
 
       default:
-        context->recordError(Error(GL_INVALID_ENUM));
+          context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (texture->getImmutableFormat() && !isSubImage)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -379,26 +379,26 @@ bool ValidateES3TexImageParametersBase(Context *context,
     {
         if (!actualFormatInfo.compressed)
         {
-            context->recordError(Error(
+            context->handleError(Error(
                 GL_INVALID_ENUM, "internalformat is not a supported compressed internal format."));
             return false;
         }
 
         if (!ValidCompressedImageSize(context, actualInternalFormat, width, height))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
         if (!actualFormatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
         }
 
         if (target == GL_TEXTURE_3D)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -411,7 +411,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
 
         if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -421,7 +421,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
     {
         if (isCompressed != actualFormatInfo.compressed)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
@@ -432,7 +432,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
 
         if (xoffset < 0 || yoffset < 0 || zoffset < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
 
@@ -440,7 +440,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
             std::numeric_limits<GLsizei>::max() - yoffset < height ||
             std::numeric_limits<GLsizei>::max() - zoffset < depth)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
 
@@ -448,7 +448,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
             static_cast<size_t>(zoffset + depth) > texture->getDepth(target, level))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return false;
         }
     }
@@ -471,7 +471,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
             !rx::IsUnsignedMultiplicationSafe(widthSize * heightSize * depthSize, pixelBytes))
         {
             // Overflow past the end of the buffer
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
@@ -483,7 +483,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
             ((offset + copyBytes) > static_cast<size_t>(pixelUnpackBuffer->getSize())))
         {
             // Overflow past the end of the buffer
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
@@ -495,7 +495,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
 
             if ((offset % dataBytesPerPixel) != 0)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return false;
             }
         }
@@ -503,7 +503,7 @@ bool ValidateES3TexImageParametersBase(Context *context,
         // ...the buffer object's data store is currently mapped.
         if (pixelUnpackBuffer->isMapped())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -530,7 +530,7 @@ bool ValidateES3TexImage2DParameters(Context *context,
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -558,7 +558,7 @@ bool ValidateES3TexImage3DParameters(Context *context,
 {
     if (!ValidTexture3DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -879,13 +879,13 @@ bool ValidateES3CopyTexImageParametersBase(ValidationContext *context,
 
     if (framebuffer->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
     if (readFramebufferID != 0 && framebuffer->getSamples(context->getData()) != 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -897,7 +897,7 @@ bool ValidateES3CopyTexImageParametersBase(ValidationContext *context,
         if (!IsValidES3CopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat,
                                                readFramebufferID))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -906,7 +906,7 @@ bool ValidateES3CopyTexImageParametersBase(ValidationContext *context,
         if (!gl::IsValidES3CopyTexImageCombination(internalformat, colorbufferInternalFormat,
                                                    readFramebufferID))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -931,7 +931,7 @@ bool ValidateES3CopyTexImage2DParameters(ValidationContext *context,
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -956,7 +956,7 @@ bool ValidateES3CopyTexImage3DParameters(ValidationContext *context,
 {
     if (!ValidTexture3DDestinationTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -975,7 +975,7 @@ bool ValidateES3TexStorageParametersBase(Context *context,
 {
     if (width < 1 || height < 1 || depth < 1 || levels < 1)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -987,7 +987,7 @@ bool ValidateES3TexStorageParametersBase(Context *context,
 
     if (levels > gl::log2(maxDim) + 1)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1000,7 +1000,7 @@ bool ValidateES3TexStorageParametersBase(Context *context,
             if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
                 static_cast<GLuint>(height) > caps.max2DTextureSize)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
         }
@@ -1010,13 +1010,13 @@ bool ValidateES3TexStorageParametersBase(Context *context,
         {
             if (width != height)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
 
             if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
         }
@@ -1028,7 +1028,7 @@ bool ValidateES3TexStorageParametersBase(Context *context,
                 static_cast<GLuint>(height) > caps.max3DTextureSize ||
                 static_cast<GLuint>(depth) > caps.max3DTextureSize)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
         }
@@ -1040,7 +1040,7 @@ bool ValidateES3TexStorageParametersBase(Context *context,
                 static_cast<GLuint>(height) > caps.max2DTextureSize ||
                 static_cast<GLuint>(depth) > caps.maxArrayTextureLayers)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
         }
@@ -1054,26 +1054,26 @@ bool ValidateES3TexStorageParametersBase(Context *context,
     gl::Texture *texture = context->getTargetTexture(target);
     if (!texture || texture->id() == 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (texture->getImmutableFormat())
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
     if (formatInfo.pixelBytes == 0)
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1090,7 +1090,7 @@ bool ValidateES3TexStorage2DParameters(Context *context,
 {
     if (!ValidTexture2DTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1108,7 +1108,7 @@ bool ValidateES3TexStorage3DParameters(Context *context,
 {
     if (!ValidTexture3DTarget(context, target))
     {
-        context->recordError(Error(GL_INVALID_ENUM));
+        context->handleError(Error(GL_INVALID_ENUM));
         return false;
     }
 
@@ -1120,7 +1120,7 @@ bool ValidateBeginQuery(gl::Context *context, GLenum target, GLuint id)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
+        context->handleError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
         return false;
     }
 
@@ -1131,7 +1131,7 @@ bool ValidateEndQuery(gl::Context *context, GLenum target)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
+        context->handleError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
         return false;
     }
 
@@ -1142,7 +1142,7 @@ bool ValidateGetQueryiv(Context *context, GLenum target, GLenum pname, GLint *pa
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
+        context->handleError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
         return false;
     }
 
@@ -1153,7 +1153,7 @@ bool ValidateGetQueryObjectuiv(Context *context, GLuint id, GLenum pname, GLuint
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
+        context->handleError(Error(GL_INVALID_OPERATION, "GLES version < 3.0"));
         return false;
     }
 
@@ -1165,13 +1165,13 @@ bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum att
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     if (layer < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1192,13 +1192,13 @@ bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum att
             {
                 if (level > gl::log2(caps.max2DTextureSize))
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
 
                 if (static_cast<GLuint>(layer) >= caps.maxArrayTextureLayers)
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
             }
@@ -1208,27 +1208,27 @@ bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum att
             {
                 if (level > gl::log2(caps.max3DTextureSize))
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
 
                 if (static_cast<GLuint>(layer) >= caps.max3DTextureSize)
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return false;
                 }
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_OPERATION));
+              context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
 
         const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(tex->getInternalFormat(tex->getTarget(), level));
         if (internalFormatInfo.compressed)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return false;
         }
     }
@@ -1325,7 +1325,7 @@ bool ValidateES3RenderbufferStorageParameters(gl::Context *context, GLenum targe
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
     if ((formatInfo.componentType == GL_UNSIGNED_INT || formatInfo.componentType == GL_INT) && samples > 0)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1333,7 +1333,7 @@ bool ValidateES3RenderbufferStorageParameters(gl::Context *context, GLenum targe
     const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
     if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION,
                   "Samples must not be greater than maximum supported value for the format."));
         return false;
@@ -1347,7 +1347,8 @@ bool ValidateInvalidateFramebuffer(Context *context, GLenum target, GLsizei numA
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Operation only supported on ES 3.0 and above"));
+        context->handleError(
+            Error(GL_INVALID_OPERATION, "Operation only supported on ES 3.0 and above"));
         return false;
     }
 
@@ -1363,7 +1364,7 @@ bool ValidateInvalidateFramebuffer(Context *context, GLenum target, GLsizei numA
         defaultFramebuffer = context->getState().getReadFramebuffer()->id() == 0;
         break;
       default:
-        context->recordError(Error(GL_INVALID_ENUM, "Invalid framebuffer target"));
+          context->handleError(Error(GL_INVALID_ENUM, "Invalid framebuffer target"));
         return false;
     }
 
@@ -1374,14 +1375,14 @@ bool ValidateClearBuffer(ValidationContext *context)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
     const gl::Framebuffer *fbo = context->getState().getDrawFramebuffer();
     if (!fbo || fbo->checkStatus(context->getData()) != GL_FRAMEBUFFER_COMPLETE)
     {
-        context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+        context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
         return false;
     }
 
@@ -1399,13 +1400,13 @@ bool ValidateDrawRangeElements(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
     if (end < start)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "end < start"));
+        context->handleError(Error(GL_INVALID_VALUE, "end < start"));
         return false;
     }
 
@@ -1417,7 +1418,7 @@ bool ValidateDrawRangeElements(Context *context,
     if (indexRange->end > end || indexRange->start < start)
     {
         // GL spec says that behavior in this case is undefined - generating an error is fine.
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_OPERATION, "Indices are out of the start, end range."));
         return false;
     }
@@ -1428,7 +1429,7 @@ bool ValidateGetUniformuiv(Context *context, GLuint program, GLint location, GLu
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1439,7 +1440,7 @@ bool ValidateReadBuffer(Context *context, GLenum src)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1447,7 +1448,7 @@ bool ValidateReadBuffer(Context *context, GLenum src)
 
     if (readFBO == nullptr)
     {
-        context->recordError(gl::Error(GL_INVALID_OPERATION, "No active read framebuffer."));
+        context->handleError(gl::Error(GL_INVALID_OPERATION, "No active read framebuffer."));
         return false;
     }
 
@@ -1458,7 +1459,7 @@ bool ValidateReadBuffer(Context *context, GLenum src)
 
     if (src != GL_BACK && (src < GL_COLOR_ATTACHMENT0 || src > GL_COLOR_ATTACHMENT31))
     {
-        context->recordError(gl::Error(GL_INVALID_ENUM, "Unknown enum for 'src' in ReadBuffer"));
+        context->handleError(gl::Error(GL_INVALID_ENUM, "Unknown enum for 'src' in ReadBuffer"));
         return false;
     }
 
@@ -1467,7 +1468,7 @@ bool ValidateReadBuffer(Context *context, GLenum src)
         if (src != GL_BACK)
         {
             const char *errorMsg = "'src' must be GL_NONE or GL_BACK when reading from the default framebuffer.";
-            context->recordError(gl::Error(GL_INVALID_OPERATION, errorMsg));
+            context->handleError(gl::Error(GL_INVALID_OPERATION, errorMsg));
             return false;
         }
     }
@@ -1478,7 +1479,7 @@ bool ValidateReadBuffer(Context *context, GLenum src)
         if (drawBuffer >= context->getCaps().maxDrawBuffers)
         {
             const char *errorMsg = "'src' is greater than MAX_DRAW_BUFFERS.";
-            context->recordError(gl::Error(GL_INVALID_OPERATION, errorMsg));
+            context->handleError(gl::Error(GL_INVALID_OPERATION, errorMsg));
             return false;
         }
     }
@@ -1499,7 +1500,7 @@ bool ValidateCompressedTexImage3D(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1508,14 +1509,14 @@ bool ValidateCompressedTexImage3D(Context *context,
         static_cast<GLuint>(imageSize) !=
             formatInfo.computeBlockSize(GL_UNSIGNED_BYTE, width, height))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     // 3D texture target validation
     if (target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY)
     {
-        context->recordError(
+        context->handleError(
             Error(GL_INVALID_ENUM, "Must specify a valid 3D texture destination target"));
         return false;
     }
@@ -1534,7 +1535,7 @@ bool ValidateBindVertexArray(Context *context, GLuint array)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1545,7 +1546,7 @@ bool ValidateIsVertexArray(Context *context)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1560,7 +1561,7 @@ bool ValidateProgramBinary(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1576,7 +1577,7 @@ bool ValidateGetProgramBinary(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1587,7 +1588,7 @@ bool ValidateProgramParameteri(Context *context, GLuint program, GLenum pname, G
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
@@ -1601,14 +1602,14 @@ bool ValidateProgramParameteri(Context *context, GLuint program, GLenum pname, G
         case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
             if (value != GL_FALSE && value != GL_TRUE)
             {
-                context->recordError(Error(
+                context->handleError(Error(
                     GL_INVALID_VALUE, "Invalid value, expected GL_FALSE or GL_TRUE: %i", value));
                 return false;
             }
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid pname: 0x%X", pname));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid pname: 0x%X", pname));
             return false;
     }
 
@@ -1629,7 +1630,7 @@ bool ValidateBlitFramebuffer(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1648,7 +1649,7 @@ bool ValidateClearBufferiv(ValidationContext *context,
             if (drawbuffer < 0 ||
                 static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
@@ -1656,13 +1657,13 @@ bool ValidateClearBufferiv(ValidationContext *context,
         case GL_STENCIL:
             if (drawbuffer != 0)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
     }
 
@@ -1680,13 +1681,13 @@ bool ValidateClearBufferuiv(ValidationContext *context,
             if (drawbuffer < 0 ||
                 static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
     }
 
@@ -1704,7 +1705,7 @@ bool ValidateClearBufferfv(ValidationContext *context,
             if (drawbuffer < 0 ||
                 static_cast<GLuint>(drawbuffer) >= context->getCaps().maxDrawBuffers)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
@@ -1712,13 +1713,13 @@ bool ValidateClearBufferfv(ValidationContext *context,
         case GL_DEPTH:
             if (drawbuffer != 0)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
     }
 
@@ -1736,13 +1737,13 @@ bool ValidateClearBufferfi(ValidationContext *context,
         case GL_DEPTH_STENCIL:
             if (drawbuffer != 0)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return false;
             }
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return false;
     }
 
@@ -1753,7 +1754,7 @@ bool ValidateDrawBuffers(ValidationContext *context, GLsizei n, const GLenum *bu
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
@@ -1773,7 +1774,7 @@ bool ValidateCopyTexSubImage3D(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1795,7 +1796,7 @@ bool ValidateTexImage3D(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1819,7 +1820,7 @@ bool ValidateTexSubImage3D(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1843,7 +1844,7 @@ bool ValidateCompressedTexSubImage3D(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -1852,13 +1853,13 @@ bool ValidateCompressedTexSubImage3D(Context *context,
         static_cast<GLuint>(imageSize) !=
             formatInfo.computeBlockSize(GL_UNSIGNED_BYTE, width, height))
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
     if (!data)
     {
-        context->recordError(Error(GL_INVALID_VALUE));
+        context->handleError(Error(GL_INVALID_VALUE));
         return false;
     }
 
@@ -1903,7 +1904,7 @@ bool ValidateDeleteTransformFeedbacks(Context *context, GLint n, const GLuint *i
         if (transformFeedback != nullptr && transformFeedback->isActive())
         {
             // ES 3.0.4 section 2.15.1 page 86
-            context->recordError(
+            context->handleError(
                 Error(GL_INVALID_OPERATION, "Attempt to delete active transform feedback."));
             return false;
         }
@@ -1925,7 +1926,7 @@ bool ValidateGenOrDeleteES3(Context *context, GLint n)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
     return ValidateGenOrDelete(context, n);
@@ -1935,12 +1936,12 @@ bool ValidateGenOrDeleteCountES3(Context *context, GLint count)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
     if (count < 0)
     {
-        context->recordError(Error(GL_INVALID_VALUE, "count < 0"));
+        context->handleError(Error(GL_INVALID_VALUE, "count < 0"));
         return false;
     }
     return true;
@@ -1950,7 +1951,7 @@ bool ValidateBeginTransformFeedback(Context *context, GLenum primitiveMode)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
     switch (primitiveMode)
@@ -1961,7 +1962,7 @@ bool ValidateBeginTransformFeedback(Context *context, GLenum primitiveMode)
             break;
 
         default:
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid primitive mode."));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid primitive mode."));
             return false;
     }
 
@@ -1970,7 +1971,7 @@ bool ValidateBeginTransformFeedback(Context *context, GLenum primitiveMode)
 
     if (transformFeedback->isActive())
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Transform feedback is already active."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Transform feedback is already active."));
         return false;
     }
     return true;
@@ -1980,13 +1981,13 @@ bool ValidateSamplerParameteri(Context *context, GLuint sampler, GLenum pname, G
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
     if (!context->isSampler(sampler))
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2013,7 +2014,7 @@ bool ValidateGetBufferPointerv(Context *context, GLenum target, GLenum pname, GL
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
@@ -2024,7 +2025,7 @@ bool ValidateUnmapBuffer(Context *context, GLenum target)
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION));
+        context->handleError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
@@ -2039,7 +2040,7 @@ bool ValidateMapBufferRange(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
@@ -2053,7 +2054,7 @@ bool ValidateFlushMappedBufferRange(Context *context,
 {
     if (context->getClientVersion() < 3)
     {
-        context->recordError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
+        context->handleError(Error(GL_INVALID_OPERATION, "Context does not support GLES3."));
         return false;
     }
 
diff --git a/src/libANGLE/validationES_unittest.cpp b/src/libANGLE/validationES_unittest.cpp
index a1ab0290f..44dadb93e 100644
--- a/src/libANGLE/validationES_unittest.cpp
+++ b/src/libANGLE/validationES_unittest.cpp
@@ -38,7 +38,7 @@ class MockValidationContext : public ValidationContext
                           const Limitations &limitations,
                           bool skipValidation);
 
-    MOCK_METHOD1(recordError, void(const Error &));
+    MOCK_METHOD1(handleError, void(const Error &));
 };
 
 MockValidationContext::MockValidationContext(GLint clientVersion,
@@ -110,7 +110,7 @@ TEST(ValidationESTest, DrawElementsWithMaxIndexGivesError)
 
     // Set the expectation for the validation error here.
     Error expectedError(GL_INVALID_OPERATION, g_ExceedsMaxElementErrorMessage);
-    EXPECT_CALL(testContext, recordError(expectedError)).Times(1);
+    EXPECT_CALL(testContext, handleError(expectedError)).Times(1);
 
     // Call once with maximum index, and once with an excessive index.
     GLuint indexData[] = {0, 1, static_cast<GLuint>(caps.maxElementIndex - 1),
diff --git a/src/libGLESv2.gypi b/src/libGLESv2.gypi
index 9fd76265c..e501c7367 100644
--- a/src/libGLESv2.gypi
+++ b/src/libGLESv2.gypi
@@ -137,6 +137,7 @@
             'libANGLE/queryconversions.h',
             'libANGLE/renderer/BufferImpl.h',
             'libANGLE/renderer/CompilerImpl.h',
+            'libANGLE/renderer/ContextImpl.h',
             'libANGLE/renderer/DeviceImpl.cpp',
             'libANGLE/renderer/DeviceImpl.h',
             'libANGLE/renderer/DisplayImpl.cpp',
@@ -245,6 +246,7 @@
             'libANGLE/renderer/d3d/d3d9/Blit9.h',
             'libANGLE/renderer/d3d/d3d9/Buffer9.cpp',
             'libANGLE/renderer/d3d/d3d9/Buffer9.h',
+            'libANGLE/renderer/d3d/d3d9/Context9.h',
             'libANGLE/renderer/d3d/d3d9/DebugAnnotator9.cpp',
             'libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h',
             'libANGLE/renderer/d3d/d3d9/Fence9.cpp',
@@ -296,6 +298,7 @@
             'libANGLE/renderer/d3d/d3d11/Buffer11.h',
             'libANGLE/renderer/d3d/d3d11/Clear11.cpp',
             'libANGLE/renderer/d3d/d3d11/Clear11.h',
+            'libANGLE/renderer/d3d/d3d11/Context11.h',
             'libANGLE/renderer/d3d/d3d11/copyvertex.h',
             'libANGLE/renderer/d3d/d3d11/copyvertex.inl',
             'libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp',
@@ -427,6 +430,7 @@
             'libANGLE/renderer/gl/BufferGL.h',
             'libANGLE/renderer/gl/CompilerGL.cpp',
             'libANGLE/renderer/gl/CompilerGL.h',
+            'libANGLE/renderer/gl/ContextGL.h',
             'libANGLE/renderer/gl/DisplayGL.cpp',
             'libANGLE/renderer/gl/DisplayGL.h',
             'libANGLE/renderer/gl/FenceNVGL.cpp',
diff --git a/src/libGLESv2/entry_points_gles_2_0.cpp b/src/libGLESv2/entry_points_gles_2_0.cpp
index 1e977b4ef..2babb5617 100644
--- a/src/libGLESv2/entry_points_gles_2_0.cpp
+++ b/src/libGLESv2/entry_points_gles_2_0.cpp
@@ -44,7 +44,7 @@ void GL_APIENTRY ActiveTexture(GLenum texture)
     {
         if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + context->getCaps().maxCombinedTextureImageUnits - 1)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -73,7 +73,7 @@ void GL_APIENTRY AttachShader(GLuint program, GLuint shader)
 
         if (!programObject->attachShader(shaderObject))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
     }
@@ -88,7 +88,7 @@ void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar*
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -101,7 +101,7 @@ void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar*
 
         if (strncmp(name, "gl_", 3) == 0)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -118,7 +118,7 @@ void GL_APIENTRY BindBuffer(GLenum target, GLuint buffer)
     {
         if (!ValidBufferTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -150,7 +150,7 @@ void GL_APIENTRY BindBuffer(GLenum target, GLuint buffer)
             return;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -165,7 +165,7 @@ void GL_APIENTRY BindFramebuffer(GLenum target, GLuint framebuffer)
     {
         if (!ValidFramebufferTarget(target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -190,7 +190,7 @@ void GL_APIENTRY BindRenderbuffer(GLenum target, GLuint renderbuffer)
     {
         if (target != GL_RENDERBUFFER)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -248,7 +248,7 @@ void GL_APIENTRY BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -262,7 +262,7 @@ void GL_APIENTRY BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -303,7 +303,7 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha
             break;
 
           default:
-              context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
               return;
         }
 
@@ -328,13 +328,13 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha
           case GL_SRC_ALPHA_SATURATE:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -358,7 +358,7 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha
             break;
 
           default:
-              context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
               return;
         }
 
@@ -383,13 +383,13 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha
           case GL_SRC_ALPHA_SATURATE:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -409,7 +409,7 @@ void GL_APIENTRY BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha
                     "Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and "
                     "GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR not supported by this "
                     "implementation.");
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return;
             }
         }
@@ -428,7 +428,7 @@ void GL_APIENTRY BufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
     {
         if (size < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -447,19 +447,19 @@ void GL_APIENTRY BufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
           case GL_DYNAMIC_COPY:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
 
           default:
-              context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
               return;
         }
 
         if (!ValidBufferTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -467,14 +467,14 @@ void GL_APIENTRY BufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
 
         if (!buffer)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         Error error = buffer->bufferData(data, size, usage);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -490,13 +490,13 @@ void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
     {
         if (size < 0 || offset < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (!ValidBufferTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -504,26 +504,26 @@ void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 
         if (!buffer)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (buffer->isMapped())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         // Check for possible overflow of size + offset
         if (!rx::IsUnsignedAdditionSafe<size_t>(size, offset))
         {
-            context->recordError(Error(GL_OUT_OF_MEMORY));
+            context->handleError(Error(GL_OUT_OF_MEMORY));
             return;
         }
 
         if (size + offset > buffer->getSize())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -535,7 +535,7 @@ void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
         Error error = buffer->bufferSubData(data, size, offset);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -550,7 +550,7 @@ GLenum GL_APIENTRY CheckFramebufferStatus(GLenum target)
     {
         if (!ValidFramebufferTarget(target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return 0;
         }
 
@@ -752,7 +752,7 @@ GLuint GL_APIENTRY CreateShader(GLenum type)
             return context->createShader(type);
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return 0;
         }
     }
@@ -775,7 +775,7 @@ void GL_APIENTRY CullFace(GLenum mode)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -840,12 +840,12 @@ void GL_APIENTRY DeleteProgram(GLuint program)
         {
             if(context->getShader(program))
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
         }
@@ -889,12 +889,12 @@ void GL_APIENTRY DeleteShader(GLuint shader)
         {
             if(context->getProgram(shader))
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return;
             }
             else
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
         }
@@ -946,7 +946,7 @@ void GL_APIENTRY DepthFunc(GLenum func)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -995,7 +995,7 @@ void GL_APIENTRY DetachShader(GLuint program, GLuint shader)
 
         if (!programObject->detachShader(shaderObject))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
     }
@@ -1010,7 +1010,7 @@ void GL_APIENTRY Disable(GLenum cap)
     {
         if (!ValidCap(context, cap))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1027,7 +1027,7 @@ void GL_APIENTRY DisableVertexAttribArray(GLuint index)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1050,7 +1050,7 @@ void GL_APIENTRY DrawArrays(GLenum mode, GLint first, GLsizei count)
         Error error = context->drawArrays(mode, first, count);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1073,7 +1073,7 @@ void GL_APIENTRY DrawElements(GLenum mode, GLsizei count, GLenum type, const GLv
         Error error = context->drawElements(mode, count, type, indices, indexRange);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1088,7 +1088,7 @@ void GL_APIENTRY Enable(GLenum cap)
     {
         if (!ValidCap(context, cap))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1097,7 +1097,7 @@ void GL_APIENTRY Enable(GLenum cap)
             if (cap == GL_SAMPLE_ALPHA_TO_COVERAGE)
             {
                 const char *errorMessage = "Current renderer doesn't support alpha-to-coverage";
-                context->recordError(Error(GL_INVALID_OPERATION, errorMessage));
+                context->handleError(Error(GL_INVALID_OPERATION, errorMessage));
 
                 // We also output an error message to the debugger window if tracing is active, so that developers can see the error message.
                 ERR("%s", errorMessage);
@@ -1119,7 +1119,7 @@ void GL_APIENTRY EnableVertexAttribArray(GLuint index)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1137,7 +1137,7 @@ void GL_APIENTRY Finish(void)
         Error error = context->finish();
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1153,7 +1153,7 @@ void GL_APIENTRY Flush(void)
         Error error = context->flush();
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1210,7 +1210,7 @@ void GL_APIENTRY FrontFace(GLenum mode)
             context->getState().setFrontFace(mode);
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -1244,7 +1244,7 @@ void GL_APIENTRY GenerateMipmap(GLenum target)
     {
         if (!ValidTextureTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1252,7 +1252,7 @@ void GL_APIENTRY GenerateMipmap(GLenum target)
 
         if (texture == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1276,14 +1276,14 @@ void GL_APIENTRY GenerateMipmap(GLenum target)
         if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0 || !formatCaps.filterable ||
             (!formatCaps.renderable && !isLUMA) || formatInfo.compressed)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         // GL_EXT_sRGB does not support mipmap generation on sRGB textures
         if (context->getClientVersion() == 2 && formatInfo.colorEncoding == GL_SRGB)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1293,21 +1293,21 @@ void GL_APIENTRY GenerateMipmap(GLenum target)
              !isPow2(static_cast<int>(texture->getHeight(baseTarget, 0)))))
         {
             ASSERT(context->getClientVersion() <= 2 && (target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP));
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         // Cube completeness check
         if (target == GL_TEXTURE_CUBE_MAP && !texture->isCubeComplete())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         Error error = texture->generateMipmaps();
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1381,7 +1381,7 @@ void GL_APIENTRY GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1394,7 +1394,7 @@ void GL_APIENTRY GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
 
         if (index >= (GLuint)programObject->getActiveAttributeCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1414,7 +1414,7 @@ void GL_APIENTRY GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1427,7 +1427,7 @@ void GL_APIENTRY GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
 
         if (index >= (GLuint)programObject->getActiveUniformCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1445,7 +1445,7 @@ void GL_APIENTRY GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* c
     {
         if (maxcount < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1476,7 +1476,7 @@ GLint GL_APIENTRY GetAttribLocation(GLuint program, const GLchar* name)
 
         if (!programObject->isLinked())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return -1;
         }
 
@@ -1520,13 +1520,13 @@ void GL_APIENTRY GetBufferParameteriv(GLenum target, GLenum pname, GLint* params
     {
         if (!ValidBufferTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (!ValidBufferParameter(context, pname))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1535,7 +1535,7 @@ void GL_APIENTRY GetBufferParameteriv(GLenum target, GLenum pname, GLint* params
         if (!buffer)
         {
             // A null buffer means that "0" is bound to the requested buffer target
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1617,7 +1617,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
     {
         if (!ValidFramebufferTarget(target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1634,7 +1634,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
           case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
             if (clientVersion < 3 && !context->getExtensions().sRGB)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
@@ -1649,13 +1649,13 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
           case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
             if (clientVersion < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1669,7 +1669,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
           case GL_DEPTH_STENCIL_ATTACHMENT:
             if (clientVersion < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
@@ -1682,7 +1682,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
             if (attachment < GL_COLOR_ATTACHMENT0_EXT ||
                 (attachment - GL_COLOR_ATTACHMENT0_EXT) >= context->getCaps().maxColorAttachments)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
@@ -1695,7 +1695,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
         {
             if (clientVersion < 3)
             {
-                context->recordError(Error(GL_INVALID_OPERATION));
+                context->handleError(Error(GL_INVALID_OPERATION));
                 return;
             }
 
@@ -1707,7 +1707,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
                 break;
 
               default:
-                context->recordError(Error(GL_INVALID_OPERATION));
+                  context->handleError(Error(GL_INVALID_OPERATION));
                 return;
             }
         }
@@ -1728,13 +1728,13 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
                   case GL_DEPTH_STENCIL_ATTACHMENT:
                     if (!framebuffer->hasValidDepthStencil())
                     {
-                        context->recordError(Error(GL_INVALID_OPERATION));
+                        context->handleError(Error(GL_INVALID_OPERATION));
                         return;
                     }
                     break;
 
                   default:
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                      context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
             }
@@ -1756,7 +1756,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                 if (attachmentObject->type() != GL_RENDERBUFFER && attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 *params = attachmentObject->id();
@@ -1765,7 +1765,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 *params = attachmentObject->mipLevel();
@@ -1774,7 +1774,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 *params = attachmentObject->cubeMapFace();
@@ -1807,7 +1807,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
                 if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
                 *params = attachmentObject->getComponentType();
@@ -1820,7 +1820,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 *params = attachmentObject->layer();
@@ -1849,7 +1849,7 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                 if (clientVersion < 3)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 *params = 0;
@@ -1858,12 +1858,12 @@ void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target, GLenum attac
               default:
                 if (clientVersion < 3)
                 {
-                    context->recordError(Error(GL_INVALID_ENUM));
+                    context->handleError(Error(GL_INVALID_ENUM));
                     return;
                 }
                 else
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
             }
@@ -1921,7 +1921,7 @@ void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint* params)
               case GL_TRANSFORM_FEEDBACK_VARYINGS:
               case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
               case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
-                context->recordError(Error(GL_INVALID_ENUM));
+                  context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
         }
@@ -1978,7 +1978,7 @@ void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint* params)
               break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -1994,7 +1994,7 @@ void GL_APIENTRY GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* len
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2017,13 +2017,13 @@ void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint*
     {
         if (target != GL_RENDERBUFFER)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (context->getState().getRenderbufferId() == 0)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2044,14 +2044,14 @@ void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint*
           case GL_RENDERBUFFER_SAMPLES_ANGLE:
             if (!context->getExtensions().framebufferMultisample)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = renderbuffer->getSamples();
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2092,7 +2092,7 @@ void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint* params)
             return;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2108,7 +2108,7 @@ void GL_APIENTRY GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* lengt
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2156,7 +2156,7 @@ void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontyp
                 break;
 
               default:
-                context->recordError(Error(GL_INVALID_ENUM));
+                  context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
@@ -2184,12 +2184,12 @@ void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontyp
                 break;
 
               default:
-                context->recordError(Error(GL_INVALID_ENUM));
+                  context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2206,7 +2206,7 @@ void GL_APIENTRY GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2264,7 +2264,7 @@ const GLubyte *GL_APIENTRY GetString(GLenum name)
                 return reinterpret_cast<const GLubyte *>(context->getExtensionString().c_str());
 
             default:
-            context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
             return nullptr;
         }
     }
@@ -2281,7 +2281,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
     {
         if (!ValidTextureTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target"));
             return;
         }
 
@@ -2289,7 +2289,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 
         if (!texture)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2310,7 +2310,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_WRAP_R:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getWrapR();
@@ -2322,7 +2322,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_IMMUTABLE_LEVELS:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getImmutableLevels();
@@ -2333,7 +2333,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_MAX_ANISOTROPY_EXT:
             if (!context->getExtensions().textureFilterAnisotropic)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getMaxAnisotropy();
@@ -2341,7 +2341,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_SWIZZLE_R:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getSwizzleRed();
@@ -2349,7 +2349,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_SWIZZLE_G:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getSwizzleGreen();
@@ -2357,7 +2357,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_SWIZZLE_B:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getSwizzleBlue();
@@ -2365,7 +2365,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_SWIZZLE_A:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getSwizzleAlpha();
@@ -2373,7 +2373,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_BASE_LEVEL:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getBaseLevel();
@@ -2381,7 +2381,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_MAX_LEVEL:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLfloat)texture->getMaxLevel();
@@ -2389,7 +2389,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_MIN_LOD:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSamplerState().minLod;
@@ -2397,7 +2397,7 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_MAX_LOD:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSamplerState().maxLod;
@@ -2405,9 +2405,8 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_COMPARE_MODE:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(
-                    Error(GL_INVALID_ENUM,
-                          "GL_TEXTURE_COMPARE_MODE not available in ES versions < 3.0"));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "GL_TEXTURE_COMPARE_MODE not available in ES versions < 3.0"));
                 return;
             }
             *params = static_cast<GLfloat>(texture->getCompareMode());
@@ -2415,15 +2414,14 @@ void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
           case GL_TEXTURE_COMPARE_FUNC:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(
-                    Error(GL_INVALID_ENUM,
-                          "GL_TEXTURE_COMPARE_FUNC not available in ES versions < 3.0"));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "GL_TEXTURE_COMPARE_FUNC not available in ES versions < 3.0"));
                 return;
             }
             *params = static_cast<GLfloat>(texture->getCompareFunc());
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2438,7 +2436,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
     {
         if (!ValidTextureTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target"));
             return;
         }
 
@@ -2446,7 +2444,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 
         if (!texture)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2467,7 +2465,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_WRAP_R:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSamplerState().wrapR;
@@ -2479,7 +2477,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_IMMUTABLE_LEVELS:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = static_cast<GLint>(texture->getImmutableLevels());
@@ -2490,7 +2488,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_MAX_ANISOTROPY_EXT:
             if (!context->getExtensions().textureFilterAnisotropic)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = (GLint)texture->getMaxAnisotropy();
@@ -2498,7 +2496,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_SWIZZLE_R:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSwizzleRed();
@@ -2506,7 +2504,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_SWIZZLE_G:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSwizzleGreen();
@@ -2514,7 +2512,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_SWIZZLE_B:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSwizzleBlue();
@@ -2522,7 +2520,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_SWIZZLE_A:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getSwizzleAlpha();
@@ -2530,7 +2528,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_BASE_LEVEL:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getBaseLevel();
@@ -2538,7 +2536,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_MAX_LEVEL:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = texture->getMaxLevel();
@@ -2546,7 +2544,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_MIN_LOD:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = iround<GLint>(texture->getMinLod());
@@ -2554,7 +2552,7 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_MAX_LOD:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             *params = iround<GLint>(texture->getMaxLod());
@@ -2562,9 +2560,8 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_COMPARE_MODE:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(
-                    Error(GL_INVALID_ENUM,
-                          "GL_TEXTURE_COMPARE_MODE not available in ES versions < 3.0"));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "GL_TEXTURE_COMPARE_MODE not available in ES versions < 3.0"));
                 return;
             }
             *params = texture->getCompareMode();
@@ -2572,15 +2569,14 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
           case GL_TEXTURE_COMPARE_FUNC:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(
-                    Error(GL_INVALID_ENUM,
-                          "GL_TEXTURE_COMPARE_FUNC not available in ES versions < 3.0"));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "GL_TEXTURE_COMPARE_FUNC not available in ES versions < 3.0"));
                 return;
             }
             *params = texture->getCompareFunc();
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2645,7 +2641,7 @@ GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar* name)
 
         if (!programObject->isLinked())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return -1;
         }
 
@@ -2664,7 +2660,7 @@ void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2698,7 +2694,7 @@ void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2733,13 +2729,13 @@ void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** po
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2762,7 +2758,7 @@ void GL_APIENTRY Hint(GLenum target, GLenum mode)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2777,7 +2773,7 @@ void GL_APIENTRY Hint(GLenum target, GLenum mode)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2810,7 +2806,7 @@ GLboolean GL_APIENTRY IsEnabled(GLenum cap)
     {
         if (!ValidCap(context, cap))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return GL_FALSE;
         }
 
@@ -2919,7 +2915,7 @@ void GL_APIENTRY LineWidth(GLfloat width)
     {
         if (width <= 0.0f)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2948,7 +2944,7 @@ void GL_APIENTRY LinkProgram(GLuint program)
         Error error = programObject->link(context->getData());
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -2967,7 +2963,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
             {
               case GL_UNPACK_IMAGE_HEIGHT:
               case GL_UNPACK_SKIP_IMAGES:
-                  context->recordError(Error(GL_INVALID_ENUM));
+                  context->handleError(Error(GL_INVALID_ENUM));
                   return;
 
               case GL_UNPACK_ROW_LENGTH:
@@ -2975,7 +2971,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
               case GL_UNPACK_SKIP_PIXELS:
                   if (!context->getExtensions().unpackSubimage)
                   {
-                      context->recordError(Error(GL_INVALID_ENUM));
+                      context->handleError(Error(GL_INVALID_ENUM));
                       return;
                   }
                   break;
@@ -2985,7 +2981,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
               case GL_PACK_SKIP_PIXELS:
                   if (!context->getExtensions().packSubimage)
                   {
-                      context->recordError(Error(GL_INVALID_ENUM));
+                      context->handleError(Error(GL_INVALID_ENUM));
                       return;
                   }
                   break;
@@ -2994,7 +2990,8 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
 
         if (param < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE, "Cannot use negative values in PixelStorei"));
+            context->handleError(
+                Error(GL_INVALID_VALUE, "Cannot use negative values in PixelStorei"));
             return;
         }
 
@@ -3005,7 +3002,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
           case GL_UNPACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
 
@@ -3015,7 +3012,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
           case GL_PACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
 
@@ -3067,7 +3064,7 @@ void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -3116,7 +3113,7 @@ void GL_APIENTRY ReleaseShaderCompiler(void)
         Error error = compiler->release();
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -3140,7 +3137,7 @@ void GL_APIENTRY RenderbufferStorage(GLenum target, GLenum internalformat, GLsiz
         Error error = renderbuffer->setStorage(internalformat, width, height);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -3167,7 +3164,7 @@ void GL_APIENTRY Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
     {
         if (width < 0 || height < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3187,7 +3184,7 @@ void GL_APIENTRY ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryfor
         const std::vector<GLenum> &shaderBinaryFormats = context->getCaps().shaderBinaryFormats;
         if (std::find(shaderBinaryFormats.begin(), shaderBinaryFormats.end(), binaryformat) == shaderBinaryFormats.end())
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3206,7 +3203,7 @@ void GL_APIENTRY ShaderSource(GLuint shader, GLsizei count, const GLchar* const*
     {
         if (count < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3239,7 +3236,7 @@ void GL_APIENTRY StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3256,7 +3253,7 @@ void GL_APIENTRY StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3292,7 +3289,7 @@ void GL_APIENTRY StencilMaskSeparate(GLenum face, GLuint mask)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3329,7 +3326,7 @@ void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenu
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3346,7 +3343,7 @@ void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenu
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3363,7 +3360,7 @@ void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenu
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3380,7 +3377,7 @@ void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenu
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3427,7 +3424,7 @@ void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param)
     {
         if (!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid texture target"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target"));
             return;
         }
 
@@ -3440,7 +3437,7 @@ void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param)
 
         if (!texture)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3484,7 +3481,7 @@ void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param)
     {
         if (!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM, "Invalid Texture target"));
+            context->handleError(Error(GL_INVALID_ENUM, "Invalid Texture target"));
             return;
         }
 
@@ -3497,7 +3494,7 @@ void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param)
 
         if (!texture)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -3840,7 +3837,7 @@ void GL_APIENTRY VertexAttrib1f(GLuint index, GLfloat x)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3858,7 +3855,7 @@ void GL_APIENTRY VertexAttrib1fv(GLuint index, const GLfloat* values)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3876,7 +3873,7 @@ void GL_APIENTRY VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3894,7 +3891,7 @@ void GL_APIENTRY VertexAttrib2fv(GLuint index, const GLfloat* values)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3912,7 +3909,7 @@ void GL_APIENTRY VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3930,7 +3927,7 @@ void GL_APIENTRY VertexAttrib3fv(GLuint index, const GLfloat* values)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3948,7 +3945,7 @@ void GL_APIENTRY VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, G
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3966,7 +3963,7 @@ void GL_APIENTRY VertexAttrib4fv(GLuint index, const GLfloat* values)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -3985,13 +3982,13 @@ void GL_APIENTRY VertexAttribPointer(GLuint index, GLint size, GLenum type, GLbo
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (size < 1 || size > 4)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -4012,25 +4009,25 @@ void GL_APIENTRY VertexAttribPointer(GLuint index, GLint size, GLenum type, GLbo
           case GL_UNSIGNED_INT_2_10_10_10_REV:
             if (context->getClientVersion() < 3)
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (stride < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if ((type == GL_INT_2_10_10_10_REV || type == GL_UNSIGNED_INT_2_10_10_10_REV) && size != 4)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -4040,7 +4037,7 @@ void GL_APIENTRY VertexAttribPointer(GLuint index, GLint size, GLenum type, GLbo
         // and the pointer argument is not NULL.
         if (context->getState().getVertexArray()->id() != 0 && context->getState().getArrayBufferId() == 0 && ptr != NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -4058,7 +4055,7 @@ void GL_APIENTRY Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
     {
         if (width < 0 || height < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
diff --git a/src/libGLESv2/entry_points_gles_2_0_ext.cpp b/src/libGLESv2/entry_points_gles_2_0_ext.cpp
index b0a2ab9b8..1bc16e6d7 100644
--- a/src/libGLESv2/entry_points_gles_2_0_ext.cpp
+++ b/src/libGLESv2/entry_points_gles_2_0_ext.cpp
@@ -93,7 +93,7 @@ void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id)
         Error error = context->beginQuery(target, id);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -114,7 +114,7 @@ void GL_APIENTRY EndQueryEXT(GLenum target)
         Error error = context->endQuery(target);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -135,7 +135,7 @@ void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target)
         Error error = context->queryCounter(id, target);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -173,7 +173,7 @@ void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
         Error error = context->getQueryObjectiv(id, pname, params);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -194,7 +194,7 @@ void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
         Error error = context->getQueryObjectuiv(id, pname, params);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -215,7 +215,7 @@ void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
         Error error = context->getQueryObjecti64v(id, pname, params);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -236,7 +236,7 @@ void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *param
         Error error = context->getQueryObjectui64v(id, pname, params);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -251,7 +251,7 @@ void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences)
     {
         if (n < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -281,7 +281,7 @@ void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode,
         Error error = context->drawArraysInstanced(mode, first, count, primcount);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -312,7 +312,7 @@ void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode,
             context->drawElementsInstanced(mode, count, type, indices, primcount, indexRange);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -329,13 +329,13 @@ void GL_APIENTRY FinishFenceNV(GLuint fence)
 
         if (fenceObject == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (fenceObject->isSet() != GL_TRUE)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -352,7 +352,7 @@ void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences)
     {
         if (n < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -374,13 +374,13 @@ void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
 
         if (fenceObject == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (fenceObject->isSet() != GL_TRUE)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -397,7 +397,7 @@ void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
                     Error error = fenceObject->test(&status);
                     if (error.isError())
                     {
-                        context->recordError(error);
+                        context->handleError(error);
                         return;
                     }
                 }
@@ -413,7 +413,7 @@ void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
 
           default:
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
         }
@@ -444,7 +444,7 @@ void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize,
     {
         if (bufsize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -452,7 +452,7 @@ void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize,
 
         if (!shaderObject)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -561,7 +561,7 @@ void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samp
         Error error = renderbuffer->setStorageMultisample(samples, internalformat, width, height);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -576,7 +576,7 @@ void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition)
     {
         if (condition != GL_ALL_COMPLETED_NV)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -584,14 +584,14 @@ void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition)
 
         if (fenceObject == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         Error error = fenceObject->set(condition);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -608,13 +608,13 @@ GLboolean GL_APIENTRY TestFenceNV(GLuint fence)
 
         if (fenceObject == NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_TRUE;
         }
 
         if (fenceObject->isSet() != GL_TRUE)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_TRUE;
         }
 
@@ -622,7 +622,7 @@ GLboolean GL_APIENTRY TestFenceNV(GLuint fence)
         Error error = fenceObject->test(&result);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return GL_TRUE;
         }
 
@@ -642,7 +642,7 @@ void GL_APIENTRY TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalf
     {
         if (!context->getExtensions().textureStorage)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -664,7 +664,7 @@ void GL_APIENTRY TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalf
         Error error = texture->setStorage(target, levels, internalformat, size);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -679,7 +679,7 @@ void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
     {
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -689,7 +689,7 @@ void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
             {
                 const char *errorMessage = "The current context doesn't support setting a non-zero divisor on the attribute with index zero. "
                                            "Please reorder the attributes in your vertex shader so that attribute zero can have a zero divisor.";
-                context->recordError(Error(GL_INVALID_OPERATION, errorMessage));
+                context->handleError(Error(GL_INVALID_OPERATION, errorMessage));
 
                 // We also output an error message to the debugger window if tracing is active, so that developers can see the error message.
                 ERR("%s", errorMessage);
@@ -772,7 +772,7 @@ void GL_APIENTRY GetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *l
         Error error = programObject->saveBinary(binaryFormat, binary, bufSize, length);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -797,7 +797,7 @@ void GL_APIENTRY ProgramBinaryOES(GLuint program, GLenum binaryFormat, const voi
         Error error = programObject->loadBinary(binaryFormat, binary, length);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -921,7 +921,7 @@ void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const char *marker)
         {
             // The debug marker calls should not set error state
             // However, it seems reasonable to set an error state if the extension is not enabled
-            context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+            context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
             return;
         }
 
@@ -946,7 +946,7 @@ void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const char *marker)
         {
             // The debug marker calls should not set error state
             // However, it seems reasonable to set an error state if the extension is not enabled
-            context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+            context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
             return;
         }
 
@@ -980,7 +980,7 @@ void GL_APIENTRY PopGroupMarkerEXT()
         {
             // The debug marker calls should not set error state
             // However, it seems reasonable to set an error state if the extension is not enabled
-            context->recordError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
+            context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
             return;
         }
 
@@ -1006,7 +1006,7 @@ ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglIma
         Error error = texture->setEGLImageTarget(target, imageObject);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1031,7 +1031,7 @@ ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target
         Error error = renderbuffer->setStorageEGLImageTarget(imageObject);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
diff --git a/src/libGLESv2/entry_points_gles_3_0.cpp b/src/libGLESv2/entry_points_gles_3_0.cpp
index 00c1f511c..e9e1eeae3 100644
--- a/src/libGLESv2/entry_points_gles_3_0.cpp
+++ b/src/libGLESv2/entry_points_gles_3_0.cpp
@@ -68,7 +68,7 @@ void GL_APIENTRY DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsize
             context->drawRangeElements(mode, start, end, count, type, indices, indexRange);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -229,7 +229,7 @@ GLboolean GL_APIENTRY IsQuery(GLuint id)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_FALSE;
         }
 
@@ -254,7 +254,7 @@ void GL_APIENTRY BeginQuery(GLenum target, GLuint id)
         Error error = context->beginQuery(target, id);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -275,7 +275,7 @@ void GL_APIENTRY EndQuery(GLenum target)
         Error error = context->endQuery(target);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -312,7 +312,7 @@ void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
         Error error = context->getQueryObjectuiv(id, pname, params);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -506,7 +506,7 @@ void GL_APIENTRY RenderbufferStorageMultisample(GLenum target, GLsizei samples,
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -667,7 +667,7 @@ void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint* data)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -679,7 +679,7 @@ void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint* data)
           case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
             if (index >= caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
@@ -689,13 +689,13 @@ void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint* data)
           case GL_UNIFORM_BUFFER_BINDING:
             if (index >= caps.maxCombinedUniformBlocks)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -705,7 +705,7 @@ void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint* data)
             unsigned int numParams = 0;
             if (!context->getIndexedQueryParameterInfo(target, &nativeType, &numParams))
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
 
@@ -763,7 +763,7 @@ void GL_APIENTRY EndTransformFeedback(void)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -772,7 +772,7 @@ void GL_APIENTRY EndTransformFeedback(void)
 
         if (!transformFeedback->isActive())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -790,7 +790,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -800,7 +800,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
           case GL_TRANSFORM_FEEDBACK_BUFFER:
             if (index >= caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
@@ -808,19 +808,19 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
           case GL_UNIFORM_BUFFER:
             if (index >= caps.maxUniformBufferBindings)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (buffer != 0 && size <= 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -831,7 +831,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
                 // size and offset must be a multiple of 4
                 if (buffer != 0 && ((offset % 4) != 0 || (size % 4) != 0))
                 {
-                    context->recordError(Error(GL_INVALID_VALUE));
+                    context->handleError(Error(GL_INVALID_VALUE));
                     return;
                 }
 
@@ -839,7 +839,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
                 if (curTransformFeedback && curTransformFeedback->isActive())
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
 
@@ -853,7 +853,7 @@ void GL_APIENTRY BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLi
             // it is an error to bind an offset not a multiple of the alignment
             if (buffer != 0 && (offset % caps.uniformBufferOffsetAlignment) != 0)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
 
@@ -877,7 +877,7 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -887,7 +887,7 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
           case GL_TRANSFORM_FEEDBACK_BUFFER:
             if (index >= caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
@@ -895,13 +895,13 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
           case GL_UNIFORM_BUFFER:
             if (index >= caps.maxUniformBufferBindings)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -913,7 +913,7 @@ void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
                 if (curTransformFeedback && curTransformFeedback->isActive())
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
 
@@ -942,13 +942,13 @@ void GL_APIENTRY TransformFeedbackVaryings(GLuint program, GLsizei count, const
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (count < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -960,12 +960,12 @@ void GL_APIENTRY TransformFeedbackVaryings(GLuint program, GLsizei count, const
           case GL_SEPARATE_ATTRIBS:
             if (static_cast<GLuint>(count) > caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -990,13 +990,13 @@ void GL_APIENTRY GetTransformFeedbackVarying(GLuint program, GLuint index, GLsiz
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (bufSize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1008,7 +1008,7 @@ void GL_APIENTRY GetTransformFeedbackVarying(GLuint program, GLuint index, GLsiz
 
         if (index >= static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount()))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1026,19 +1026,19 @@ void GL_APIENTRY VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLs
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (size < 1 || size > 4)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1055,19 +1055,19 @@ void GL_APIENTRY VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLs
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (stride < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if ((type == GL_INT_2_10_10_10_REV || type == GL_UNSIGNED_INT_2_10_10_10_REV) && size != 4)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1077,7 +1077,7 @@ void GL_APIENTRY VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLs
         // and the pointer argument is not NULL.
         if (context->getState().getVertexArray()->id() != 0 && context->getState().getArrayBufferId() == 0 && pointer != NULL)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1096,13 +1096,13 @@ void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1137,13 +1137,13 @@ void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1178,13 +1178,13 @@ void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1203,13 +1203,13 @@ void GL_APIENTRY VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GL
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1227,13 +1227,13 @@ void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint* v)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1250,13 +1250,13 @@ void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint* v)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1294,13 +1294,13 @@ GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return -1;
         }
 
         if (program == 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return -1;
         }
 
@@ -1308,7 +1308,7 @@ GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name)
 
         if (!programObject || !programObject->isLinked())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return -1;
         }
 
@@ -1494,19 +1494,19 @@ const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return NULL;
         }
 
         if (name != GL_EXTENSIONS)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return NULL;
         }
 
         if (index >= context->getExtensionStringCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return NULL;
         }
 
@@ -1526,13 +1526,13 @@ void GL_APIENTRY CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintp
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (!ValidBufferTarget(context, readTarget) || !ValidBufferTarget(context, writeTarget))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -1541,14 +1541,14 @@ void GL_APIENTRY CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintp
 
         if (!readBuffer || !writeBuffer)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         // Verify that readBuffer and writeBuffer are not currently mapped
         if (readBuffer->isMapped() || writeBuffer->isMapped())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1556,13 +1556,13 @@ void GL_APIENTRY CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintp
             static_cast<unsigned int>(readOffset + size) > readBuffer->getSize() ||
             static_cast<unsigned int>(writeOffset + size) > writeBuffer->getSize())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (readBuffer == writeBuffer && std::abs(readOffset - writeOffset) < size)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1572,7 +1572,7 @@ void GL_APIENTRY CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintp
             Error error = writeBuffer->copyBufferSubData(readBuffer, readOffset, writeOffset, size);
             if (error.isError())
             {
-                context->recordError(error);
+                context->handleError(error);
                 return;
             }
         }
@@ -1589,13 +1589,13 @@ void GL_APIENTRY GetUniformIndices(GLuint program, GLsizei uniformCount, const G
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (uniformCount < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1633,13 +1633,13 @@ void GL_APIENTRY GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (uniformCount < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1663,13 +1663,13 @@ void GL_APIENTRY GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (uniformCount > programObject->getActiveUniformCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1679,7 +1679,7 @@ void GL_APIENTRY GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const
 
             if (index >= static_cast<GLuint>(programObject->getActiveUniformCount()))
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
         }
@@ -1701,7 +1701,7 @@ GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program, const GLchar* uniformBlo
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_INVALID_INDEX;
         }
 
@@ -1727,7 +1727,7 @@ void GL_APIENTRY GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockInde
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
         Program *programObject = GetValidProgram(context, program);
@@ -1739,7 +1739,7 @@ void GL_APIENTRY GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockInde
 
         if (uniformBlockIndex >= programObject->getActiveUniformBlockCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1759,7 +1759,7 @@ void GL_APIENTRY GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockInde
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -1775,7 +1775,7 @@ void GL_APIENTRY GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIn
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1788,7 +1788,7 @@ void GL_APIENTRY GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIn
 
         if (uniformBlockIndex >= programObject->getActiveUniformBlockCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1806,13 +1806,13 @@ void GL_APIENTRY UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, G
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (uniformBlockBinding >= context->getCaps().maxUniformBufferBindings)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1826,7 +1826,7 @@ void GL_APIENTRY UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, G
         // if never linked, there won't be any uniform blocks
         if (uniformBlockIndex >= programObject->getActiveUniformBlockCount())
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1844,7 +1844,7 @@ void GL_APIENTRY DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GL
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1856,7 +1856,7 @@ void GL_APIENTRY DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GL
         Error error = context->drawArraysInstanced(mode, first, count, instanceCount);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1872,7 +1872,7 @@ void GL_APIENTRY DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -1886,7 +1886,7 @@ void GL_APIENTRY DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
             context->drawElementsInstanced(mode, count, type, indices, instanceCount, indexRange);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -1901,19 +1901,19 @@ GLsync GL_APIENTRY FenceSync_(GLenum condition, GLbitfield flags)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return 0;
         }
 
         if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return 0;
         }
 
         if (flags != 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return 0;
         }
 
@@ -1924,7 +1924,7 @@ GLsync GL_APIENTRY FenceSync_(GLenum condition, GLbitfield flags)
         if (error.isError())
         {
             context->deleteFenceSync(fenceSync);
-            context->recordError(error);
+            context->handleError(error);
             return NULL;
         }
 
@@ -1943,7 +1943,7 @@ GLboolean GL_APIENTRY IsSync(GLsync sync)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_FALSE;
         }
 
@@ -1962,13 +1962,13 @@ void GL_APIENTRY DeleteSync(GLsync sync)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (sync != static_cast<GLsync>(0) && !context->getFenceSync(sync))
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -1986,13 +1986,13 @@ GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeou
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_WAIT_FAILED;
         }
 
         if ((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return GL_WAIT_FAILED;
         }
 
@@ -2000,7 +2000,7 @@ GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeou
 
         if (!fenceSync)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return GL_WAIT_FAILED;
         }
 
@@ -2008,7 +2008,7 @@ GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeou
         Error error = fenceSync->clientWait(flags, timeout, &result);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return GL_WAIT_FAILED;
         }
 
@@ -2028,19 +2028,19 @@ void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (flags != 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         if (timeout != GL_TIMEOUT_IGNORED)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2048,14 +2048,14 @@ void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 
         if (!fenceSync)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
         Error error = fenceSync->serverWait(flags, timeout);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
         }
     }
 }
@@ -2070,7 +2070,7 @@ void GL_APIENTRY GetInteger64v(GLenum pname, GLint64* params)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2102,13 +2102,13 @@ void GL_APIENTRY GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei*
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (bufSize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2116,7 +2116,7 @@ void GL_APIENTRY GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei*
 
         if (!fenceSync)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2131,14 +2131,14 @@ void GL_APIENTRY GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei*
                 Error error = fenceSync->getStatus(values);
                 if (error.isError())
                 {
-                    context->recordError(error);
+                    context->handleError(error);
                     return;
                 }
                 break;
             }
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2154,7 +2154,7 @@ void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2166,7 +2166,7 @@ void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
           case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
             if (index >= caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
@@ -2176,13 +2176,13 @@ void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
           case GL_UNIFORM_BUFFER_BINDING:
             if (index >= caps.maxUniformBufferBindings)
             {
-                context->recordError(Error(GL_INVALID_VALUE));
+                context->handleError(Error(GL_INVALID_VALUE));
                 return;
             }
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2192,7 +2192,7 @@ void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
             unsigned int numParams = 0;
             if (!context->getIndexedQueryParameterInfo(target, &nativeType, &numParams))
             {
-                context->recordError(Error(GL_INVALID_ENUM));
+                context->handleError(Error(GL_INVALID_ENUM));
                 return;
             }
 
@@ -2230,19 +2230,19 @@ void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* pa
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (!ValidBufferTarget(context, target))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (!ValidBufferParameter(context, pname))
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
@@ -2251,7 +2251,7 @@ void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* pa
         if (!buffer)
         {
             // A null buffer means that "0" is bound to the requested buffer target
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2327,7 +2327,7 @@ GLboolean GL_APIENTRY IsSampler(GLuint sampler)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_FALSE;
         }
 
@@ -2346,19 +2346,19 @@ void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (sampler != 0 && !context->isSampler(sampler))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (unit >= context->getCaps().maxCombinedTextureImageUnits)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2419,7 +2419,7 @@ void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* para
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2430,7 +2430,7 @@ void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* para
 
         if (!context->isSampler(sampler))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2447,7 +2447,7 @@ void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* pa
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2458,7 +2458,7 @@ void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* pa
 
         if (!context->isSampler(sampler))
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2475,13 +2475,13 @@ void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         if (index >= MAX_VERTEX_ATTRIBS)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2498,7 +2498,7 @@ void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2510,14 +2510,14 @@ void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
                 TransformFeedback *curTransformFeedback = context->getState().getCurrentTransformFeedback();
                 if (curTransformFeedback && curTransformFeedback->isActive() && !curTransformFeedback->isPaused())
                 {
-                    context->recordError(Error(GL_INVALID_OPERATION));
+                    context->handleError(Error(GL_INVALID_OPERATION));
                     return;
                 }
 
                 // Cannot bind a transform feedback object that does not exist (3.0.2 pg 85 section 2.14.1)
                 if (!context->isTransformFeedbackGenerated(id))
                 {
-                    context->recordError(
+                    context->handleError(
                         Error(GL_INVALID_OPERATION,
                               "Cannot bind a transform feedback object that does not exist."));
                     return;
@@ -2528,7 +2528,7 @@ void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
@@ -2581,7 +2581,7 @@ GLboolean GL_APIENTRY IsTransformFeedback(GLuint id)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return GL_FALSE;
         }
 
@@ -2608,7 +2608,7 @@ void GL_APIENTRY PauseTransformFeedback(void)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2618,7 +2618,7 @@ void GL_APIENTRY PauseTransformFeedback(void)
         // Current transform feedback must be active and not paused in order to pause (3.0.2 pg 86)
         if (!transformFeedback->isActive() || transformFeedback->isPaused())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2635,7 +2635,7 @@ void GL_APIENTRY ResumeTransformFeedback(void)
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2645,7 +2645,7 @@ void GL_APIENTRY ResumeTransformFeedback(void)
         // Current transform feedback must be active and paused in order to resume (3.0.2 pg 86)
         if (!transformFeedback->isActive() || !transformFeedback->isPaused())
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2672,7 +2672,7 @@ void GL_APIENTRY GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* leng
         Error error = programObject->saveBinary(binaryFormat, binary, bufSize, length);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -2697,7 +2697,7 @@ void GL_APIENTRY ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid
         Error error = programObject->loadBinary(binaryFormat, binary, length);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -2768,7 +2768,7 @@ void GL_APIENTRY TexStorage2D(GLenum target, GLsizei levels, GLenum internalform
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2783,7 +2783,7 @@ void GL_APIENTRY TexStorage2D(GLenum target, GLsizei levels, GLenum internalform
         Error error = texture->setStorage(target, levels, internalformat, size);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -2800,7 +2800,7 @@ void GL_APIENTRY TexStorage3D(GLenum target, GLsizei levels, GLenum internalform
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
@@ -2815,7 +2815,7 @@ void GL_APIENTRY TexStorage3D(GLenum target, GLsizei levels, GLenum internalform
         Error error = texture->setStorage(target, levels, internalformat, size);
         if (error.isError())
         {
-            context->recordError(error);
+            context->handleError(error);
             return;
         }
     }
@@ -2832,26 +2832,26 @@ void GL_APIENTRY GetInternalformativ(GLenum target, GLenum internalformat, GLenu
     {
         if (context->getClientVersion() < 3)
         {
-            context->recordError(Error(GL_INVALID_OPERATION));
+            context->handleError(Error(GL_INVALID_OPERATION));
             return;
         }
 
         const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
         if (!formatCaps.renderable)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (target != GL_RENDERBUFFER)
         {
-            context->recordError(Error(GL_INVALID_ENUM));
+            context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
 
         if (bufSize < 0)
         {
-            context->recordError(Error(GL_INVALID_VALUE));
+            context->handleError(Error(GL_INVALID_VALUE));
             return;
         }
 
@@ -2876,7 +2876,7 @@ void GL_APIENTRY GetInternalformativ(GLenum target, GLenum internalformat, GLenu
             break;
 
           default:
-            context->recordError(Error(GL_INVALID_ENUM));
+              context->handleError(Error(GL_INVALID_ENUM));
             return;
         }
     }
diff --git a/src/libGLESv2/global_state.cpp b/src/libGLESv2/global_state.cpp
index b99c3e1ca..fa681bde1 100644
--- a/src/libGLESv2/global_state.cpp
+++ b/src/libGLESv2/global_state.cpp
@@ -133,7 +133,7 @@ Context *GetValidGlobalContext()
     {
         if (context->isContextLost())
         {
-            context->recordError(gl::Error(GL_OUT_OF_MEMORY, "Context has been lost."));
+            context->handleError(gl::Error(GL_OUT_OF_MEMORY, "Context has been lost."));
             return nullptr;
         }
         else
diff --git a/src/tests/angle_unittests_utils.h b/src/tests/angle_unittests_utils.h
index 970e2f411..0aa976f61 100644
--- a/src/tests/angle_unittests_utils.h
+++ b/src/tests/angle_unittests_utils.h
@@ -62,6 +62,7 @@ class NullFactory : public ImplFactory
 class MockFactory : public ImplFactory
 {
   public:
+    MOCK_METHOD0(createContext, ContextImpl *());
     MOCK_METHOD0(createCompiler, CompilerImpl *());
     MOCK_METHOD1(createShader, ShaderImpl *(const gl::ShaderState &));
     MOCK_METHOD1(createProgram, ProgramImpl *(const gl::ProgramState &));