Enclose error(GLint) and error(EGLint) into gl and egl namespaces.

src/libEGL/Display.cpp

@@ -436,7 +436,7 @@ void Display::notifyDeviceLost()
     {
         (*context)->markContextLost();
     }
-    error(EGL_CONTEXT_LOST);
+    egl::error(EGL_CONTEXT_LOST);
 }
 
 bool Display::isInitialized() const

src/libEGL/libEGL.cpp

@@ -22,12 +22,12 @@ bool validateDisplay(egl::Display *display)
 {
     if (display == EGL_NO_DISPLAY)
     {
-        return error(EGL_BAD_DISPLAY, false);
+        return egl::error(EGL_BAD_DISPLAY, false);
     }
 
     if (!display->isInitialized())
     {
-        return error(EGL_NOT_INITIALIZED, false);
+        return egl::error(EGL_NOT_INITIALIZED, false);
     }
 
     return true;
@@ -42,7 +42,7 @@ bool validateConfig(egl::Display *display, EGLConfig config)
 
     if (!display->isValidConfig(config))
     {
-        return error(EGL_BAD_CONFIG, false);
+        return egl::error(EGL_BAD_CONFIG, false);
     }
 
     return true;
@@ -57,7 +57,7 @@ bool validateContext(egl::Display *display, gl::Context *context)
 
     if (!display->isValidContext(context))
     {
-        return error(EGL_BAD_CONTEXT, false);
+        return egl::error(EGL_BAD_CONTEXT, false);
     }
 
     return true;
@@ -72,7 +72,7 @@ bool validateSurface(egl::Display *display, egl::Surface *surface)
 
     if (!display->isValidSurface(surface))
     {
-        return error(EGL_BAD_SURFACE, false);
+        return egl::error(EGL_BAD_SURFACE, false);
     }
 
     return true;
@@ -104,7 +104,7 @@ EGLDisplay __stdcall eglGetDisplay(EGLNativeDisplayType display_id)
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
     }
 }
 
@@ -117,24 +117,24 @@ EGLBoolean __stdcall eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
     {
         if (dpy == EGL_NO_DISPLAY)
         {
-            return error(EGL_BAD_DISPLAY, EGL_FALSE);
+            return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
 
         if (!display->initialize())
         {
-            return error(EGL_NOT_INITIALIZED, EGL_FALSE);
+            return egl::error(EGL_NOT_INITIALIZED, EGL_FALSE);
         }
 
         if (major) *major = 1;
         if (minor) *minor = 4;
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -146,18 +146,18 @@ EGLBoolean __stdcall eglTerminate(EGLDisplay dpy)
     {
         if (dpy == EGL_NO_DISPLAY)
         {
-            return error(EGL_BAD_DISPLAY, EGL_FALSE);
+            return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
 
         display->terminate();
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -177,20 +177,20 @@ const char *__stdcall eglQueryString(EGLDisplay dpy, EGLint name)
         switch (name)
         {
           case EGL_CLIENT_APIS:
-            return success("OpenGL_ES");
+            return egl::success("OpenGL_ES");
           case EGL_EXTENSIONS:
             return display->getExtensionString();
           case EGL_VENDOR:
-            return success("Google Inc.");
+            return egl::success("Google Inc.");
           case EGL_VERSION:
-            return success("1.4 (ANGLE " VERSION_STRING ")");
+            return egl::success("1.4 (ANGLE " VERSION_STRING ")");
         }
 
-        return error(EGL_BAD_PARAMETER, (const char*)NULL);
+        return egl::error(EGL_BAD_PARAMETER, (const char*)NULL);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, (const char*)NULL);
+        return egl::error(EGL_BAD_ALLOC, (const char*)NULL);
     }
 }
 
@@ -211,21 +211,21 @@ EGLBoolean __stdcall eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint co
 
         if (!num_config)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         const EGLint attribList[] =    {EGL_NONE};
 
         if (!display->getConfigs(configs, attribList, config_size, num_config))
         {
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -246,7 +246,7 @@ EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
 
         if (!num_config)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         const EGLint attribList[] =    {EGL_NONE};
@@ -258,11 +258,11 @@ EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
 
         display->getConfigs(configs, attrib_list, config_size, num_config);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -282,14 +282,14 @@ EGLBoolean __stdcall eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint
 
         if (!display->getConfigAttrib(config, attribute, value))
         {
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -311,14 +311,14 @@ EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EG
 
         if (!IsWindow(window))
         {
-            return error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
         }
 
         return display->createWindowSurface(window, config, attrib_list);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -340,7 +340,7 @@ EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, c
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -360,11 +360,11 @@ EGLSurface __stdcall eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EG
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(EGL_NO_SURFACE);
+        return egl::success(EGL_NO_SURFACE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -384,16 +384,16 @@ EGLBoolean __stdcall eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         display->destroySurface((egl::Surface*)surface);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -414,7 +414,7 @@ EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         switch (attribute)
@@ -471,14 +471,14 @@ EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint
             *value = eglSurface->isPostSubBufferSupported();
             break;
           default:
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -499,7 +499,7 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         switch (attribute)
@@ -511,14 +511,14 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
             }
             break;
           default:
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -532,20 +532,20 @@ EGLBoolean __stdcall eglBindAPI(EGLenum api)
         {
           case EGL_OPENGL_API:
           case EGL_OPENVG_API:
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);   // Not supported by this implementation
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);   // Not supported by this implementation
           case EGL_OPENGL_ES_API:
             break;
           default:
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         egl::setCurrentAPI(api);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -557,11 +557,11 @@ EGLenum __stdcall eglQueryAPI(void)
     {
         EGLenum API = egl::getCurrentAPI();
 
-        return success(API);
+        return egl::success(API);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -573,11 +573,11 @@ EGLBoolean __stdcall eglWaitClient(void)
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -589,11 +589,11 @@ EGLBoolean __stdcall eglReleaseThread(void)
     {
         eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -614,14 +614,14 @@ EGLSurface __stdcall eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum bu
 
         if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE || !buffer)
         {
-            return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
         }
 
         return display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -642,11 +642,11 @@ EGLBoolean __stdcall eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -666,34 +666,34 @@ EGLBoolean __stdcall eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint
 
         if (buffer != EGL_BACK_BUFFER)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->getBoundTexture())
         {
-            return error(EGL_BAD_ACCESS, EGL_FALSE);
+            return egl::error(EGL_BAD_ACCESS, EGL_FALSE);
         }
 
         if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
         if (!glBindTexImage(eglSurface))
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -713,17 +713,17 @@ EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
 
         if (buffer != EGL_BACK_BUFFER)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
         gl::Texture2D *texture = eglSurface->getBoundTexture();
@@ -733,11 +733,11 @@ EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
             texture->releaseTexImage();
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -758,16 +758,16 @@ EGLBoolean __stdcall eglSwapInterval(EGLDisplay dpy, EGLint interval)
 
         if (draw_surface == NULL)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
         
         draw_surface->setSwapInterval(interval);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -795,32 +795,32 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte
                   case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
                     if (attribute[1] == EGL_TRUE)
                     {
-                        return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);   // Unimplemented
+                        return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);   // Unimplemented
                         // robust_access = true;
                     }
                     else if (attribute[1] != EGL_FALSE)
-                        return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                        return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                     break;
                   case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
                     if (attribute[1] == EGL_LOSE_CONTEXT_ON_RESET_EXT)
                         reset_notification = true;
                     else if (attribute[1] != EGL_NO_RESET_NOTIFICATION_EXT)
-                        return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                        return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                     break;
                   default:
-                    return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                    return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                 }
             }
         }
 
         if (client_version != 2)
         {
-            return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
+            return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
         }
 
         if (share_context && static_cast<gl::Context*>(share_context)->isResetNotificationEnabled() != reset_notification)
         {
-            return error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
+            return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -833,13 +833,13 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte
         EGLContext context = display->createContext(config, static_cast<gl::Context*>(share_context), reset_notification, robust_access);
 
         if (context)
-            return success(context);
+            return egl::success(context);
         else
-            return error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
+            return egl::error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
     }
 }
 
@@ -859,16 +859,16 @@ EGLBoolean __stdcall eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 
         if (ctx == EGL_NO_CONTEXT)
         {
-            return error(EGL_BAD_CONTEXT, EGL_FALSE);
+            return egl::error(EGL_BAD_CONTEXT, EGL_FALSE);
         }
 
         display->destroyContext(context);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -895,7 +895,7 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
 
         if (renderer->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if ((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) ||
@@ -915,11 +915,11 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
 
         glMakeCurrent(context, display, static_cast<egl::Surface*>(draw));
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -931,11 +931,11 @@ EGLContext __stdcall eglGetCurrentContext(void)
     {
         EGLContext context = glGetCurrentContext();
 
-        return success(context);
+        return egl::success(context);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
     }
 }
 
@@ -948,21 +948,21 @@ EGLSurface __stdcall eglGetCurrentSurface(EGLint readdraw)
         if (readdraw == EGL_READ)
         {
             EGLSurface read = egl::getCurrentReadSurface();
-            return success(read);
+            return egl::success(read);
         }
         else if (readdraw == EGL_DRAW)
         {
             EGLSurface draw = egl::getCurrentDrawSurface();
-            return success(draw);
+            return egl::success(draw);
         }
         else
         {
-            return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -974,11 +974,11 @@ EGLDisplay __stdcall eglGetCurrentDisplay(void)
     {
         EGLDisplay dpy = egl::getCurrentDisplay();
 
-        return success(dpy);
+        return egl::success(dpy);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
     }
 }
 
@@ -999,11 +999,11 @@ EGLBoolean __stdcall eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attr
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1015,11 +1015,11 @@ EGLBoolean __stdcall eglWaitGL(void)
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1031,11 +1031,11 @@ EGLBoolean __stdcall eglWaitNative(EGLint engine)
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1055,22 +1055,22 @@ EGLBoolean __stdcall eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->swap())
         {
-            return success(EGL_TRUE);
+            return egl::success(EGL_TRUE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 
     return EGL_FALSE;
@@ -1092,16 +1092,16 @@ EGLBoolean __stdcall eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativ
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1113,7 +1113,7 @@ EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLi
     {
         if (x < 0 || y < 0 || width < 0 || height < 0)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -1126,22 +1126,22 @@ EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLi
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->postSubBuffer(x, y, width, height))
         {
-            return success(EGL_TRUE);
+            return egl::success(EGL_TRUE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 
     return EGL_FALSE;
@@ -1178,7 +1178,7 @@ __eglMustCastToProperFunctionPointerType __stdcall eglGetProcAddress(const char
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
+        return egl::error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
     }
 }
 }

src/libEGL/main.cpp

@@ -157,9 +157,10 @@ EGLSurface getCurrentReadSurface()
 
     return current->readSurface;
 }
-}
 
 void error(EGLint errorCode)
 {
     egl::setCurrentError(errorCode);
 }
+
+}

src/libEGL/main.h

@@ -38,7 +38,6 @@ EGLSurface getCurrentDrawSurface();
 
 void setCurrentReadSurface(EGLSurface surface);
 EGLSurface getCurrentReadSurface();
-}
 
 void error(EGLint errorCode);
 
@@ -58,4 +57,6 @@ const T &success(const T &returnValue)
     return returnValue;
 }
 
+}
+
 #endif  // LIBEGL_MAIN_H_

src/libGLESv2/Context.cpp

@@ -982,7 +982,7 @@ void Context::beginQuery(GLenum target, GLuint query)
     {
         if (mState.activeQuery[i].get() != NULL)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1005,13 +1005,13 @@ void Context::beginQuery(GLenum target, GLuint query)
     // check that name was obtained with glGenQueries
     if (!queryObject)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     // check for type mismatch
     if (queryObject->getType() != target)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     // set query as active for specified target
@@ -1042,7 +1042,7 @@ void Context::endQuery(GLenum target)
 
     if (queryObject == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     queryObject->end();
@@ -1471,7 +1471,7 @@ bool Context::getIntegerv(GLenum pname, GLint *params)
         {
             if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
             {
-                error(GL_INVALID_OPERATION);
+                gl::error(GL_INVALID_OPERATION);
                 return false;
             }
 
@@ -1482,7 +1482,7 @@ bool Context::getIntegerv(GLenum pname, GLint *params)
         {
             if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
             {
-                error(GL_INVALID_OPERATION);
+                gl::error(GL_INVALID_OPERATION);
                 return false;
             }
 
@@ -1694,7 +1694,7 @@ bool Context::applyRenderTarget(GLenum drawMode, bool ignoreViewport)
 
     if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
     }
 
     mRenderer->applyRenderTarget(framebufferObject);
@@ -1826,12 +1826,12 @@ void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
 
     if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     if (getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     GLsizei outputPitch = ComputePitch(width, ConvertSizedInternalFormat(format, type), getPackAlignment());
@@ -1841,7 +1841,7 @@ void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
         int requiredSize = outputPitch * height;
         if (requiredSize > *bufSize)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1854,7 +1854,7 @@ void Context::clear(GLbitfield mask)
 
     if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     DWORD flags = 0;
@@ -1900,7 +1900,7 @@ void Context::clear(GLbitfield mask)
 
     if (mask != 0)
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     if (!applyRenderTarget(GL_TRIANGLES, true))   // Clips the clear to the scissor rectangle but not the viewport
@@ -1926,7 +1926,7 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instan
 {
     if (!mState.currentProgram)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!mRenderer->applyPrimitiveType(mode, count))
@@ -1946,7 +1946,7 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instan
     GLenum err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, first, count, instances);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     applyShaders();
@@ -1954,7 +1954,7 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instan
 
     if (!programBinary->validateSamplers(NULL))
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!skipDraw(mode))
@@ -1967,12 +1967,12 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid
 {
     if (!mState.currentProgram)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!indices && !mState.elementArrayBuffer)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
     
     if (!mRenderer->applyPrimitiveType(mode, count))
@@ -1991,7 +1991,7 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid
     GLenum err = mRenderer->applyIndexBuffer(indices, mState.elementArrayBuffer.get(), count, mode, type, &indexInfo);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     ProgramBinary *programBinary = getCurrentProgramBinary();
@@ -2000,7 +2000,7 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid
     err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, indexInfo.minIndex, vertexCount, instances);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     applyShaders();
@@ -2008,7 +2008,7 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid
 
     if (!programBinary->validateSamplers(NULL))
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!skipDraw(mode))
@@ -2262,13 +2262,13 @@ bool Context::getCurrentReadFormatType(GLenum *format, GLenum *type)
     Framebuffer *framebuffer = getReadFramebuffer();
     if (!framebuffer || framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     Renderbuffer *renderbuffer = framebuffer->getColorbuffer();
     if (!renderbuffer)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     *format = gl::ExtractFormat(renderbuffer->getActualFormat()); 
@@ -2619,12 +2619,12 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
     if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
         !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     if (drawFramebuffer->getSamples() != 0)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     int readBufferWidth = readFramebuffer->getColorbuffer()->getWidth();
@@ -2797,12 +2797,12 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
             readFramebuffer->getColorbuffer()->getActualFormat() != drawFramebuffer->getColorbuffer()->getActualFormat())
         {
             ERR("Color buffer format conversion in BlitFramebufferANGLE not supported by this implementation");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
         
         if (partialBufferCopy && readFramebuffer->getSamples() != 0)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         blitRenderTarget = true;
@@ -2824,7 +2824,7 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
                 if (readFramebuffer->getDepthbufferType() != drawFramebuffer->getDepthbufferType() ||
                     readFramebuffer->getDepthbuffer()->getActualFormat() != drawFramebuffer->getDepthbuffer()->getActualFormat())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 blitDepthStencil = true;
@@ -2840,7 +2840,7 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
                 if (readFramebuffer->getStencilbufferType() != drawFramebuffer->getStencilbufferType() ||
                     readFramebuffer->getStencilbuffer()->getActualFormat() != drawFramebuffer->getStencilbuffer()->getActualFormat())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 blitDepthStencil = true;
@@ -2852,13 +2852,13 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
         if (partialBufferCopy)
         {
             ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
-            return error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
+            return gl::error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
         }
 
         if ((drawDSBuffer && drawDSBuffer->getSamples() != 0) || 
             (readDSBuffer && readDSBuffer->getSamples() != 0))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 

src/libGLESv2/Texture.cpp

@@ -513,7 +513,7 @@ void Texture2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yo
 {
     if (xoffset + width > mImageArray[level]->getWidth() || yoffset + height > mImageArray[level]->getHeight())
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     if (!mImageArray[level]->isRenderableFormat() || (!mTexStorage && !isSamplerComplete()))
@@ -740,7 +740,7 @@ void Texture2D::convertToRenderTarget()
             if (!mRenderer->copyToRenderTarget(newTexStorage, mTexStorage))
             {   
                 delete newTexStorage;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
     }
@@ -757,7 +757,7 @@ void Texture2D::generateMipmaps()
     {
         if (!isPow2(mImageArray[0]->getWidth()) || !isPow2(mImageArray[0]->getHeight()))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -792,7 +792,7 @@ Renderbuffer *Texture2D::getRenderbuffer(GLenum target)
 {
     if (target != GL_TEXTURE_2D)
     {
-        return error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
+        return gl::error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
     }
 
     if (mColorbufferProxy == NULL)
@@ -1199,7 +1199,7 @@ void TextureCubeMap::convertToRenderTarget()
             if (!mRenderer->copyToRenderTarget(newTexStorage, mTexStorage))
             {
                 delete newTexStorage;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
     }
@@ -1291,7 +1291,7 @@ void TextureCubeMap::copySubImage(GLenum target, GLint level, GLint xoffset, GLi
 
     if (xoffset + width > size || yoffset + height > size)
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     unsigned int faceindex = faceIndex(target);
@@ -1365,14 +1365,14 @@ void TextureCubeMap::generateMipmaps()
 {
     if (!isCubeComplete())
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!mRenderer->getNonPower2TextureSupport())
     {
         if (!isPow2(mImageArray[0][0]->getWidth()))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1416,7 +1416,7 @@ Renderbuffer *TextureCubeMap::getRenderbuffer(GLenum target)
 {
     if (!IsCubemapTextureTarget(target))
     {
-        return error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
+        return gl::error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
     }
 
     unsigned int face = faceIndex(target);

src/libGLESv2/main.cpp

@@ -101,7 +101,7 @@ Context *getNonLostContext()
     {
         if (context->isContextLost())
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
             return NULL;
         }
         else
@@ -119,8 +119,6 @@ egl::Display *getDisplay()
     return current->display;
 }
 
-}
-
 // Records an error code
 void error(GLenum errorCode)
 {
@@ -154,3 +152,6 @@ void error(GLenum errorCode)
         }
     }
 }
+
+}
+

src/libGLESv2/main.h

@@ -32,8 +32,6 @@ Context *getContext();
 Context *getNonLostContext();
 egl::Display *getDisplay();
 
-}
-
 void error(GLenum errorCode);
 
 template<class T>
@@ -44,6 +42,8 @@ const T &error(GLenum errorCode, const T &returnValue)
     return returnValue;
 }
 
+}
+
 extern "C"
 {
 // Exported functions for use by EGL

src/libGLESv2/renderer/Blit.cpp

@@ -85,7 +85,7 @@ void Blit::initGeometry()
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void *lockPtr = NULL;
@@ -94,7 +94,7 @@ void Blit::initGeometry()
     if (FAILED(result) || lockPtr == NULL)
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     memcpy(lockPtr, quad, sizeof(quad));
@@ -111,7 +111,7 @@ void Blit::initGeometry()
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -230,7 +230,7 @@ bool Blit::copy(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum des
     if (!source)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());
@@ -266,7 +266,7 @@ bool Blit::copy(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum des
     if (!source)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());
@@ -306,7 +306,7 @@ bool Blit::copy(IDirect3DSurface9 *source, const RECT &sourceRect, GLenum destFo
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
     }
     else
@@ -428,7 +428,7 @@ IDirect3DTexture9 *Blit::copySurfaceToTexture(IDirect3DSurface9 *surface, const
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     IDirect3DSurface9 *textureSurface;
@@ -438,7 +438,7 @@ IDirect3DTexture9 *Blit::copySurfaceToTexture(IDirect3DSurface9 *surface, const
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         texture->Release();
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     mRenderer->endScene();
@@ -450,7 +450,7 @@ IDirect3DTexture9 *Blit::copySurfaceToTexture(IDirect3DSurface9 *surface, const
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         texture->Release();
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     return texture;

src/libGLESv2/renderer/Fence11.cpp

@@ -44,7 +44,7 @@ void Fence11::setFence(GLenum condition)
 
         if (FAILED(mRenderer->getDevice()->CreateQuery(&queryDesc, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -58,14 +58,14 @@ GLboolean Fence11::testFence()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION, GL_TRUE);
+        return gl::error(GL_INVALID_OPERATION, GL_TRUE);
     }
 
     HRESULT result = mRenderer->getDeviceContext()->GetData(mQuery, NULL, 0, 0);
 
     if (mRenderer->isDeviceLost())
     {
-       return error(GL_OUT_OF_MEMORY, GL_TRUE);
+       return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
@@ -77,7 +77,7 @@ void Fence11::finishFence()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     while (!testFence())
@@ -90,7 +90,7 @@ void Fence11::getFenceiv(GLenum pname, GLint *params)
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     switch (pname)
@@ -111,7 +111,7 @@ void Fence11::getFenceiv(GLenum pname, GLint *params)
             if (mRenderer->isDeviceLost())
             {
                 params[0] = GL_TRUE;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
 
             ASSERT(result == S_OK || result == S_FALSE);
@@ -124,7 +124,7 @@ void Fence11::getFenceiv(GLenum pname, GLint *params)
         params[0] = getCondition();
         break;
       default:
-        return error(GL_INVALID_ENUM);
+        return gl::error(GL_INVALID_ENUM);
         break;
     }
 }

src/libGLESv2/renderer/Fence9.cpp

@@ -42,7 +42,7 @@ void Fence9::setFence(GLenum condition)
         mQuery = mRenderer->allocateEventQuery();
         if (!mQuery)
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -57,7 +57,7 @@ GLboolean Fence9::testFence()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION, GL_TRUE);
+        return gl::error(GL_INVALID_OPERATION, GL_TRUE);
     }
 
     HRESULT result = mQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
@@ -65,7 +65,7 @@ GLboolean Fence9::testFence()
     if (d3d9::isDeviceLostError(result))
     {
         mRenderer->notifyDeviceLost();
-        return error(GL_OUT_OF_MEMORY, GL_TRUE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
@@ -77,7 +77,7 @@ void Fence9::finishFence()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     while (!testFence())
@@ -90,7 +90,7 @@ void Fence9::getFenceiv(GLenum pname, GLint *params)
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     switch (pname)
@@ -112,7 +112,7 @@ void Fence9::getFenceiv(GLenum pname, GLint *params)
             {
                 params[0] = GL_TRUE;
                 mRenderer->notifyDeviceLost();
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
 
             ASSERT(result == S_OK || result == S_FALSE);
@@ -125,7 +125,7 @@ void Fence9::getFenceiv(GLenum pname, GLint *params)
             params[0] = getCondition();
             break;
         default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
             break;
     }
 }

src/libGLESv2/renderer/Image11.cpp

@@ -389,7 +389,7 @@ void Image11::createStagingTexture()
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 

src/libGLESv2/renderer/Image9.cpp

@@ -106,7 +106,7 @@ void Image9::generateMipmap(Image9 *dest, Image9 *source)
 {
     IDirect3DSurface9 *sourceSurface = source->getSurface();
     if (sourceSurface == NULL)
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
 
     IDirect3DSurface9 *destSurface = dest->getSurface();
     generateMip(destSurface, sourceSurface);
@@ -199,7 +199,7 @@ void Image9::createSurface()
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             ERR("Creating image surface failed.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         newTexture->GetSurfaceLevel(levelToFetch, &newSurface);
@@ -500,7 +500,7 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
     if (!surface)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
@@ -515,7 +515,7 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
     {
         ERR("Could not create matching destination surface.");
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     result = device->GetRenderTargetData(surface, renderTargetData);
@@ -525,7 +525,7 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
         ERR("GetRenderTargetData unexpectedly failed.");
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     RECT sourceRect = {x, y, x + width, y + height};
@@ -539,7 +539,7 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
         ERR("Failed to lock the source surface (rectangle might be invalid).");
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     D3DLOCKED_RECT destLock = {0};
@@ -551,7 +551,7 @@ void Image9::copy(GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
         renderTargetData->UnlockRect();
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (destLock.pBits && sourceLock.pBits)

src/libGLESv2/renderer/Query11.cpp

@@ -37,7 +37,7 @@ void Query11::begin()
 
         if (FAILED(mRenderer->getDevice()->CreateQuery(&queryDesc, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -48,7 +48,7 @@ void Query11::end()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     mRenderer->getDeviceContext()->End(mQuery);
@@ -68,7 +68,7 @@ GLuint Query11::getResult()
             // if the device is lost
             if (mRenderer->testDeviceLost(true))
             {
-                return error(GL_OUT_OF_MEMORY, 0);
+                return gl::error(GL_OUT_OF_MEMORY, 0);
             }
         }
     }
@@ -108,7 +108,7 @@ GLboolean Query11::testQuery()
         }
         else if (mRenderer->testDeviceLost(true))
         {
-            return error(GL_OUT_OF_MEMORY, GL_TRUE);
+            return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
         }
 
         return getStatus();

src/libGLESv2/renderer/Query9.cpp

@@ -35,7 +35,7 @@ void Query9::begin()
     {
         if (FAILED(mRenderer->getDevice()->CreateQuery(D3DQUERYTYPE_OCCLUSION, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -47,7 +47,7 @@ void Query9::end()
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     HRESULT result = mQuery->Issue(D3DISSUE_END);
@@ -69,7 +69,7 @@ GLuint Query9::getResult()
             // instead of D3DERR_DEVICELOST like they should
             if (mRenderer->testDeviceLost(true))
             {
-                return error(GL_OUT_OF_MEMORY, 0);
+                return gl::error(GL_OUT_OF_MEMORY, 0);
             }
         }
     }
@@ -111,7 +111,7 @@ GLboolean Query9::testQuery()
         else if (d3d9::isDeviceLostError(hres))
         {
             mRenderer->notifyDeviceLost();
-            return error(GL_OUT_OF_MEMORY, GL_TRUE);
+            return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
         }
 
         return getStatus();

src/libGLESv2/renderer/RenderTarget11.cpp

@@ -233,7 +233,7 @@ RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height
 
     if (supportedSamples == -1)
     {
-        error(GL_OUT_OF_MEMORY);
+        gl::error(GL_OUT_OF_MEMORY);
 
         return;
     }
@@ -262,7 +262,7 @@ RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height
 
         if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
             return;
         }
         ASSERT(SUCCEEDED(result));
@@ -279,7 +279,7 @@ RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
                 rtTexture->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));
@@ -295,7 +295,7 @@ RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
                 rtTexture->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));
@@ -311,7 +311,7 @@ RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height
             {
                 rtTexture->Release();
                 mRenderTarget->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));

src/libGLESv2/renderer/RenderTarget9.cpp

@@ -45,7 +45,7 @@ RenderTarget9::RenderTarget9(Renderer *renderer, GLsizei width, GLsizei height,
 
     if (supportedSamples == -1)
     {
-        error(GL_OUT_OF_MEMORY);
+        gl::error(GL_OUT_OF_MEMORY);
 
         return;
     }
@@ -69,7 +69,7 @@ RenderTarget9::RenderTarget9(Renderer *renderer, GLsizei width, GLsizei height,
 
         if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
 
             return;
         }

src/libGLESv2/renderer/Renderer.cpp

@@ -143,7 +143,7 @@ ID3DBlob *Renderer::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, cons
         {
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
-                return error(GL_OUT_OF_MEMORY, (ID3DBlob*) NULL);
+                return gl::error(GL_OUT_OF_MEMORY, (ID3DBlob*) NULL);
             }
 
             infoLog.append("Warning: D3D shader compilation failed with ");

src/libGLESv2/renderer/Renderer11.cpp

@@ -535,7 +535,7 @@ void Renderer11::setDepthStencilState(const gl::DepthStencilState &depthStencilS
         {
             ERR("Separate front/back stencil writemasks, reference values, or stencil mask values are "
                 "invalid under WebGL.");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         ID3D11DepthStencilState *dxDepthStencilState = mStateCache.getDepthStencilState(depthStencilState);
@@ -663,7 +663,7 @@ bool Renderer11::applyPrimitiveType(GLenum mode, GLsizei count)
           // emulate fans via rewriting index buffer
       case GL_TRIANGLE_FAN:   primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;	break;
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 
     mDeviceContext->IASetPrimitiveTopology(primitiveTopology);
@@ -914,7 +914,7 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
             mLineLoopIB = NULL;
 
             ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -922,7 +922,7 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
     if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
     {
         ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void* mappedMemory = NULL;
@@ -930,7 +930,7 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
     if (offset == -1 || mappedMemory == NULL)
     {
         ERR("Could not map index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
@@ -972,7 +972,7 @@ void Renderer11::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
     if (!mLineLoopIB->unmapBuffer())
     {
         ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (mAppliedIBSerial != mLineLoopIB->getSerial() || mAppliedIBOffset != indexBufferOffset)
@@ -1006,7 +1006,7 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
             mTriangleFanIB = NULL;
 
             ERR("Could not create a scratch index buffer for GL_TRIANGLE_FAN.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -1015,7 +1015,7 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
     if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
     {
         ERR("Could not reserve enough space in scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void* mappedMemory = NULL;
@@ -1023,7 +1023,7 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
     if (offset == -1 || mappedMemory == NULL)
     {
         ERR("Could not map scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
@@ -1069,7 +1069,7 @@ void Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indic
     if (!mTriangleFanIB->unmapBuffer())
     {
         ERR("Could not unmap scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (mAppliedIBSerial != mTriangleFanIB->getSerial() || mAppliedIBOffset != indexBufferOffset)
@@ -1781,6 +1781,8 @@ bool Renderer11::testDeviceLost(bool notify)
     if (isLost)
     {
         // ensure we note the device loss --
+        // we'll probably get this done again by notifyDeviceLost
+        // but best to remember it!
         // Note that we don't want to clear the device loss status here
         // -- this needs to be done by resetDevice
         mDeviceLost = true;
@@ -2160,21 +2162,21 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
     if (!sourceRenderTarget)
     {
         ERR("Failed to retrieve the render target from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
     if (!source)
     {
         ERR("Failed to retrieve the render target view from the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
@@ -2182,7 +2184,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the texture storage from the destination.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(level));
@@ -2190,7 +2192,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the render target from the destination storage.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
@@ -2198,7 +2200,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the render target view from the destination render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     gl::Rectangle destRect;
@@ -2223,21 +2225,21 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
     if (!sourceRenderTarget)
     {
         ERR("Failed to retrieve the render target from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
     if (!source)
     {
         ERR("Failed to retrieve the render target view from the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
@@ -2245,7 +2247,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the texture storage from the destination.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(target, level));
@@ -2253,7 +2255,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the render target from the destination storage.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
@@ -2261,7 +2263,7 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
     {
         source->Release();
         ERR("Failed to retrieve the render target view from the destination render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     gl::Rectangle destRect;
@@ -2358,7 +2360,7 @@ bool Renderer11::copyTexture(ID3D11ShaderResourceView *source, const gl::Rectang
         destArea.x < 0 || destArea.x + destArea.width > static_cast<int>(destWidth) ||
         destArea.y < 0 || destArea.y + destArea.height > static_cast<int>(destHeight))
     {
-        return error(GL_INVALID_VALUE, false);
+        return gl::error(GL_INVALID_VALUE, false);
     }
 
     // Set vertices
@@ -2367,7 +2369,7 @@ bool Renderer11::copyTexture(ID3D11ShaderResourceView *source, const gl::Rectang
     if (FAILED(result))
     {
         ERR("Failed to map vertex buffer for texture copy, HRESULT: 0x%X.", result);
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);

src/libGLESv2/renderer/Renderer9.cpp

@@ -955,7 +955,7 @@ void Renderer9::setDepthStencilState(const gl::DepthStencilState &depthStencilSt
                 depthStencilState.stencilMask != depthStencilState.stencilBackMask)
             {
                 ERR("Separate front/back stencil writemasks, reference values, or stencil mask values are invalid under WebGL.");
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             // get the maximum size of the stencil ref
@@ -1149,7 +1149,7 @@ bool Renderer9::applyPrimitiveType(GLenum mode, GLsizei count)
         mPrimitiveCount = count - 2;
         break;
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 
     return mPrimitiveCount > 0;
@@ -1397,7 +1397,7 @@ void Renderer9::drawArrays(GLenum mode, GLsizei count, GLsizei instances)
         else
         {
             ERR("Could not create a counting index buffer for glDrawArraysInstanced.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
     else   // Regular case
@@ -1447,7 +1447,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
                 mLineLoopIB = NULL;
 
                 ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
 
@@ -1455,7 +1455,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
         {
             ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         void* mappedMemory = NULL;
@@ -1463,7 +1463,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (offset == -1 || mappedMemory == NULL)
         {
             ERR("Could not map index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         startIndex = static_cast<UINT>(offset) / 4;
@@ -1505,7 +1505,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (!mLineLoopIB->unmapBuffer())
         {
             ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
     else
@@ -1519,7 +1519,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
                 mLineLoopIB = NULL;
 
                 ERR("Could not create a 16-bit looping index buffer for GL_LINE_LOOP.");
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
 
@@ -1527,7 +1527,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT))
         {
             ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         void* mappedMemory = NULL;
@@ -1535,7 +1535,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (offset == -1 || mappedMemory == NULL)
         {
             ERR("Could not map index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         startIndex = static_cast<UINT>(offset) / 2;
@@ -1577,7 +1577,7 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
         if (!mLineLoopIB->unmapBuffer())
         {
             ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -2048,6 +2048,8 @@ bool Renderer9::testDeviceLost(bool notify)
     if (isLost)
     {
         // ensure we note the device loss --
+        // we'll probably get this done again by notifyDeviceLost
+        // but best to remember it!
         // Note that we don't want to clear the device loss status here
         // -- this needs to be done by resetDevice
         mDeviceLost = true;
@@ -2547,7 +2549,7 @@ bool Renderer9::blitRect(gl::Framebuffer *readFramebuffer, gl::Rectangle *readRe
         if (!readSurface || !drawSurface)
         {
             ERR("Failed to retrieve the render target.");
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
 
         RECT srcRect, dstRect;
@@ -2614,7 +2616,7 @@ bool Renderer9::blitRect(gl::Framebuffer *readFramebuffer, gl::Rectangle *readRe
         if (!readSurface || !drawSurface)
         {
             ERR("Failed to retrieve the render target.");
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
 
         HRESULT result = mDevice->StretchRect(readSurface, NULL, drawSurface, NULL, D3DTEXF_NONE);
@@ -2662,7 +2664,7 @@ void Renderer9::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsiz
     {
         UNIMPLEMENTED();   // FIXME: Requires resolve using StretchRect into non-multisampled render target
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     HRESULT result;
@@ -2690,7 +2692,7 @@ void Renderer9::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsiz
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             surface->Release();
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -2707,7 +2709,7 @@ void Renderer9::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsiz
         if (d3d9::isDeviceLostError(result))
         {
             notifyDeviceLost();
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {

src/libGLESv2/renderer/TextureStorage11.cpp

@@ -239,7 +239,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {
@@ -298,7 +298,7 @@ RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
 
             if (result == E_OUTOFMEMORY)
             {
-                return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
             }
             ASSERT(SUCCEEDED(result));
 
@@ -314,7 +314,7 @@ RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
             if (result == E_OUTOFMEMORY)
             {
                 rtv->Release();
-                return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
             }
             ASSERT(SUCCEEDED(result));
 
@@ -352,7 +352,7 @@ ID3D11ShaderResourceView *TextureStorage11_2D::getSRV()
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
+            return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
         ASSERT(SUCCEEDED(result));
     }
@@ -414,7 +414,7 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLe
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {
@@ -481,7 +481,7 @@ RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int leve
 
                 if (result == E_OUTOFMEMORY)
                 {
-                    return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                    return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
                 }
                 ASSERT(SUCCEEDED(result));
 
@@ -499,7 +499,7 @@ RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int leve
                 if (result == E_OUTOFMEMORY)
                 {
                     rtv->Release();
-                    return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                    return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
                 }
                 ASSERT(SUCCEEDED(result));
 
@@ -544,7 +544,7 @@ ID3D11ShaderResourceView *TextureStorage11_Cube::getSRV()
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
+            return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
         ASSERT(SUCCEEDED(result));
     }

src/libGLESv2/renderer/TextureStorage9.cpp

@@ -134,7 +134,7 @@ TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, int levels, GLenum in
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -236,7 +236,7 @@ TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, int levels, GLenu
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
     }