ANGLE: Upgrade to version 1.2.30d6c255d238

The following patches have been changed: 0001-Fix-compilation-for-MSVC-2008-and-std-tuple.patch Removed because it is no longer possible to build ANGLE with MSVC2008 0002-Fix-compilation-of-ANGLE-with-mingw-tdm64-gcc-4.8.1.patch Removed because the minimum version of MinGW moved to 4.8.2 0005-Fix-build-when-SSE2-is-not-available.patch Removed because it was fixed upstream 0006-Fix-compilation-of-libGLESv2-with-older-MinGW-w64-he.patch Removed because older versions of MinGW are not supported 0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch Removed because it was fixed upstream Task-number: QTBUG-41903 Change-Id: I976d30802f7f6fee725cf9a9f1325d5e82609835 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com> Reviewed-by: Kai Koehne <kai.koehne@theqtcompany.com> Reviewed-by: Oliver Wolff <oliver.wolff@theqtcompany.com>
author: Andrew Knight <andrew.knight@theqtcompany.com> 2014-11-14 10:52:01 +0200
committer: Jani Heikkinen <jani.heikkinen@theqtcompany.com> 2014-11-14 19:01:38 +0100
commit: c6df5fe3ed0f2a722931be098914978cf17a666f (patch)
tree: 23abe340dbc427a3afd255c79316f79fef937059 /src/3rdparty/angle/src/libEGL
parent: 32db2f425a0b85bc03d7de42d7b44337d0aa16f4 (diff)
11 files changed, 743 insertions, 534 deletions
diff --git a/src/3rdparty/angle/src/libEGL/AttributeMap.cpp b/src/3rdparty/angle/src/libEGL/AttributeMap.cpp
new file mode 100644
index 0000000000..28dd3d842e
--- /dev/null
+++ b/src/3rdparty/angle/src/libEGL/AttributeMap.cpp
@@ -0,0 +1,40 @@
+//
+// Copyright (c) 2014 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.
+//
+
+#include "libEGL/AttributeMap.h"
+
+namespace egl
+{
+
+AttributeMap::AttributeMap()
+{
+}
+
+AttributeMap::AttributeMap(const EGLint *attributes)
+{
+    for (const EGLint *curAttrib = attributes; curAttrib[0] != EGL_NONE; curAttrib += 2)
+    {
+        insert(curAttrib[0], curAttrib[1]);
+    }
+}
+
+void AttributeMap::insert(EGLint key, EGLint value)
+{
+    mAttributes[key] = value;
+}
+
+bool AttributeMap::contains(EGLint key) const
+{
+    return (mAttributes.find(key) != mAttributes.end());
+}
+
+EGLint AttributeMap::get(EGLint key, EGLint defaultValue) const
+{
+    std::map<EGLint, EGLint>::const_iterator iter = mAttributes.find(key);
+    return (mAttributes.find(key) != mAttributes.end()) ? iter->second : defaultValue;
+}
+
+}
diff --git a/src/3rdparty/angle/src/libEGL/AttributeMap.h b/src/3rdparty/angle/src/libEGL/AttributeMap.h
new file mode 100644
index 0000000000..f2f082fe21
--- /dev/null
+++ b/src/3rdparty/angle/src/libEGL/AttributeMap.h
@@ -0,0 +1,33 @@
+//
+// Copyright (c) 2014 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.
+//
+
+#ifndef LIBEGL_ATTRIBUTEMAP_H_
+#define LIBEGL_ATTRIBUTEMAP_H_
+
+#include <EGL/egl.h>
+
+#include <map>
+
+namespace egl
+{
+
+class AttributeMap
+{
+  public:
+    AttributeMap();
+    explicit AttributeMap(const EGLint *attributes);
+
+    virtual void insert(EGLint key, EGLint value);
+    virtual bool contains(EGLint key) const;
+    virtual EGLint get(EGLint key, EGLint defaultValue) const;
+
+  private:
+    std::map<EGLint, EGLint> mAttributes;
+};
+
+}
+
+#endif   // LIBEGL_ATTRIBUTEMAP_H_
diff --git a/src/3rdparty/angle/src/libEGL/Display.cpp b/src/3rdparty/angle/src/libEGL/Display.cpp
index 5a50e4baf5..eea93b1d87 100644
--- a/src/3rdparty/angle/src/libEGL/Display.cpp
+++ b/src/3rdparty/angle/src/libEGL/Display.cpp
@@ -35,32 +35,36 @@ static DisplayMap *GetDisplayMap()
     return &displays;
 }
 
-egl::Display *Display::getDisplay(EGLNativeDisplayType displayId, EGLint displayType)
+egl::Display *Display::getDisplay(EGLNativeDisplayType displayId, const AttributeMap &attribMap)
 {
+    Display *display = NULL;
+
     DisplayMap *displays = GetDisplayMap();
     DisplayMap::const_iterator iter = displays->find(displayId);
     if (iter != displays->end())
     {
-        return iter->second;
+        display = iter->second;
+    }
+    else
+    {
+        display = new egl::Display(displayId);
+        displays->insert(std::make_pair(displayId, display));
     }
-    
-    // FIXME: Check if displayId is a valid display device context
 
-    egl::Display *display = new egl::Display(displayId, displayType);
-    displays->insert(std::make_pair(displayId, display));
+    // Apply new attributes if the display is not initialized yet.
+    if (!display->isInitialized())
+    {
+        display->setAttributes(attribMap);
+    }
 
     return display;
 }
 
-Display::Display(EGLNativeDisplayType displayId, EGLint displayType)
+Display::Display(EGLNativeDisplayType displayId)
     : mDisplayId(displayId),
-      mRequestedDisplayType(displayType),
+      mAttributeMap(),
       mRenderer(NULL)
 {
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (mDisplayId)
-        mDisplayId->AddRef();
-#endif
 }
 
 Display::~Display()
@@ -73,28 +77,29 @@ Display::~Display()
     {
         displays->erase(iter);
     }
+}
 
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (mDisplayId)
-        mDisplayId->Release();
-#endif
+void Display::setAttributes(const AttributeMap &attribMap)
+{
+    mAttributeMap = attribMap;
 }
 
-bool Display::initialize()
+Error Display::initialize()
 {
     if (isInitialized())
     {
-        return true;
+        return Error(EGL_SUCCESS);
     }
 
-    mRenderer = glCreateRenderer(this, mDisplayId, mRequestedDisplayType);
+    mRenderer = glCreateRenderer(this, mDisplayId, mAttributeMap);
 
     if (!mRenderer)
     {
         terminate();
-        return error(EGL_NOT_INITIALIZED, false);
+        return Error(EGL_NOT_INITIALIZED);
     }
 
+    //TODO(jmadill): should be part of caps?
     EGLint minSwapInterval = mRenderer->getMinSwapInterval();
     EGLint maxSwapInterval = mRenderer->getMaxSwapInterval();
     EGLint maxTextureSize = mRenderer->getRendererCaps().max2DTextureSize;
@@ -125,13 +130,13 @@ bool Display::initialize()
     if (!isInitialized())
     {
         terminate();
-        return false;
+        return Error(EGL_NOT_INITIALIZED);
     }
 
     initDisplayExtensionString();
     initVendorString();
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
 void Display::terminate()
@@ -148,6 +153,8 @@ void Display::terminate()
 
     glDestroyRenderer(mRenderer);
     mRenderer = NULL;
+
+    mConfigSet.mSet.clear();
 }
 
 bool Display::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig)
@@ -202,7 +209,7 @@ bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
 
 
 
-EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList)
+Error Display::createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList, EGLSurface *outSurface)
 {
     const Config *configuration = mConfigSet.get(config);
     EGLint postSubBufferSupported = EGL_FALSE;
@@ -223,9 +230,9 @@ EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig co
                   case EGL_BACK_BUFFER:
                     break;
                   case EGL_SINGLE_BUFFER:
-                    return error(EGL_BAD_MATCH, EGL_NO_SURFACE);   // Rendering directly to front buffer not supported
+                    return Error(EGL_BAD_MATCH);   // Rendering directly to front buffer not supported
                   default:
-                    return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                    return Error(EGL_BAD_ATTRIBUTE);
                 }
                 break;
               case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
@@ -241,11 +248,11 @@ EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig co
                 fixedSize = attribList[1];
                 break;
               case EGL_VG_COLORSPACE:
-                return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+                return Error(EGL_BAD_MATCH);
               case EGL_VG_ALPHA_FORMAT:
-                return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+                return Error(EGL_BAD_MATCH);
               default:
-                return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                return Error(EGL_BAD_ATTRIBUTE);
             }
 
             attribList += 2;
@@ -254,7 +261,7 @@ EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig co
 
     if (width < 0 || height < 0)
     {
-        return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+        return Error(EGL_BAD_PARAMETER);
     }
 
     if (!fixedSize)
@@ -265,29 +272,33 @@ EGLSurface Display::createWindowSurface(EGLNativeWindowType window, EGLConfig co
 
     if (hasExistingWindowSurface(window))
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return Error(EGL_BAD_ALLOC);
     }
 
     if (mRenderer->testDeviceLost(false))
     {
-        if (!restoreLostDevice())
-            return EGL_NO_SURFACE;
+        Error error = restoreLostDevice();
+        if (error.isError())
+        {
+            return error;
+        }
     }
 
     Surface *surface = new Surface(this, configuration, window, fixedSize, width, height, postSubBufferSupported);
-
-    if (!surface->initialize())
+    Error error = surface->initialize();
+    if (error.isError())
     {
-        delete surface;
-        return EGL_NO_SURFACE;
+        SafeDelete(surface);
+        return error;
     }
 
     mSurfaceSet.insert(surface);
 
-    return success(surface);
+    *outSurface = surface;
+    return Error(EGL_SUCCESS);
 }
 
-EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList)
+Error Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList, EGLSurface *outSurface)
 {
     EGLint width = 0, height = 0;
     EGLenum textureFormat = EGL_NO_TEXTURE;
@@ -319,7 +330,7 @@ EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle,
                     textureFormat = attribList[1];
                     break;
                   default:
-                    return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                    return Error(EGL_BAD_ATTRIBUTE);
                 }
                 break;
               case EGL_TEXTURE_TARGET:
@@ -330,19 +341,19 @@ EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle,
                     textureTarget = attribList[1];
                     break;
                   default:
-                    return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                    return Error(EGL_BAD_ATTRIBUTE);
                 }
                 break;
               case EGL_MIPMAP_TEXTURE:
                 if (attribList[1] != EGL_FALSE)
-                  return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                  return Error(EGL_BAD_ATTRIBUTE);
                 break;
               case EGL_VG_COLORSPACE:
-                return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+                return Error(EGL_BAD_MATCH);
               case EGL_VG_ALPHA_FORMAT:
-                return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+                return Error(EGL_BAD_MATCH);
               default:
-                return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+                return Error(EGL_BAD_ATTRIBUTE);
             }
 
             attribList += 2;
@@ -351,88 +362,100 @@ EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle,
 
     if (width < 0 || height < 0)
     {
-        return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+        return Error(EGL_BAD_PARAMETER);
     }
 
     if (width == 0 || height == 0)
     {
-        return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+        return Error(EGL_BAD_ATTRIBUTE);
     }
 
     if (textureFormat != EGL_NO_TEXTURE && !mRenderer->getRendererExtensions().textureNPOT && (!gl::isPow2(width) || !gl::isPow2(height)))
     {
-        return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+        return Error(EGL_BAD_MATCH);
     }
 
     if ((textureFormat != EGL_NO_TEXTURE && textureTarget == EGL_NO_TEXTURE) ||
         (textureFormat == EGL_NO_TEXTURE && textureTarget != EGL_NO_TEXTURE))
     {
-        return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+        return Error(EGL_BAD_MATCH);
     }
 
     if (!(configuration->mSurfaceType & EGL_PBUFFER_BIT))
     {
-        return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
+        return Error(EGL_BAD_MATCH);
     }
 
     if ((textureFormat == EGL_TEXTURE_RGB && configuration->mBindToTextureRGB != EGL_TRUE) ||
         (textureFormat == EGL_TEXTURE_RGBA && configuration->mBindToTextureRGBA != EGL_TRUE))
     {
-        return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+        return Error(EGL_BAD_ATTRIBUTE);
     }
 
     if (mRenderer->testDeviceLost(false))
     {
-        if (!restoreLostDevice())
-            return EGL_NO_SURFACE;
+        Error error = restoreLostDevice();
+        if (error.isError())
+        {
+            return error;
+        }
     }
 
     Surface *surface = new Surface(this, configuration, shareHandle, width, height, textureFormat, textureTarget);
-
-    if (!surface->initialize())
+    Error error = surface->initialize();
+    if (error.isError())
     {
-        delete surface;
-        return EGL_NO_SURFACE;
+        SafeDelete(surface);
+        return error;
     }
 
     mSurfaceSet.insert(surface);
 
-    return success(surface);
+    *outSurface = surface;
+    return Error(EGL_SUCCESS);
 }
 
-EGLContext Display::createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets, bool robustAccess)
+Error Display::createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets,
+                             bool robustAccess, EGLContext *outContext)
 {
     if (!mRenderer)
     {
-        return EGL_NO_CONTEXT;
+        *outContext = EGL_NO_CONTEXT;
+        return Error(EGL_SUCCESS);
     }
     else if (mRenderer->testDeviceLost(false))   // Lost device
     {
-        if (!restoreLostDevice())
+        Error error = restoreLostDevice();
+        if (error.isError())
         {
-            return error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
+            return error;
         }
     }
 
+    //TODO(jmadill): shader model is not cross-platform
     if (clientVersion > 2 && mRenderer->getMajorShaderModel() < 4)
     {
-        return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
+        return Error(EGL_BAD_CONFIG);
     }
 
     gl::Context *context = glCreateContext(clientVersion, shareContext, mRenderer, notifyResets, robustAccess);
     mContextSet.insert(context);
 
-    return success(context);
+    *outContext = context;
+    return Error(EGL_SUCCESS);
 }
 
-bool Display::restoreLostDevice()
+Error Display::restoreLostDevice()
 {
     for (ContextSet::iterator ctx = mContextSet.begin(); ctx != mContextSet.end(); ctx++)
     {
         if ((*ctx)->isResetNotificationEnabled())
-            return false;   // If reset notifications have been requested, application must delete all contexts first
+        {
+            // If reset notifications have been requested, application must delete all contexts first
+            return Error(EGL_CONTEXT_LOST);
+        }
     }
- 
+
     // Release surface resources to make the Reset() succeed
     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
     {
@@ -441,16 +464,20 @@ bool Display::restoreLostDevice()
 
     if (!mRenderer->resetDevice())
     {
-        return error(EGL_BAD_ALLOC, false);
+        return Error(EGL_BAD_ALLOC);
     }
 
     // Restore any surfaces that may have been lost
     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
     {
-        (*surface)->resetSwapChain();
+        Error error = (*surface)->resetSwapChain();
+        if (error.isError())
+        {
+            return error;
+        }
     }
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
 
@@ -472,7 +499,6 @@ void Display::notifyDeviceLost()
     {
         (*context)->markContextLost();
     }
-    egl::error(EGL_CONTEXT_LOST);
 }
 
 void Display::recreateSwapChains()
@@ -604,10 +630,11 @@ void Display::initVendorString()
 
     LUID adapterLuid = {0};
 
+    //TODO(jmadill): LUID is not cross-platform
     if (mRenderer && mRenderer->getLUID(&adapterLuid))
     {
         char adapterLuidString[64];
-        snprintf(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart);
+        sprintf_s(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart);
 
         mVendorString += adapterLuidString;
     }
diff --git a/src/3rdparty/angle/src/libEGL/Display.h b/src/3rdparty/angle/src/libEGL/Display.h
index 73ba7673ff..b3ffcc84c5 100644
--- a/src/3rdparty/angle/src/libEGL/Display.h
+++ b/src/3rdparty/angle/src/libEGL/Display.h
@@ -14,7 +14,9 @@
 #include <set>
 #include <vector>
 
+#include "libEGL/Error.h"
 #include "libEGL/Config.h"
+#include "libEGL/AttributeMap.h"
 
 namespace gl
 {
@@ -30,10 +32,10 @@ class Display
   public:
     ~Display();
 
-    bool initialize();
+    Error initialize();
     void terminate();
 
-    static egl::Display *getDisplay(EGLNativeDisplayType displayId, EGLint displayType);
+    static egl::Display *getDisplay(EGLNativeDisplayType displayId, const AttributeMap &attribMap);
 
     static const char *getExtensionString(egl::Display *display);
 
@@ -43,9 +45,10 @@ class Display
     bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
     bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
 
-    EGLSurface createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList);
-    EGLSurface createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList);
-    EGLContext createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets, bool robustAccess);
+    Error createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList, EGLSurface *outSurface);
+    Error createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList, EGLSurface *outSurface);
+    Error createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets,
+                        bool robustAccess, EGLContext *outContext);
 
     void destroySurface(egl::Surface *surface);
     void destroyContext(gl::Context *context);
@@ -64,18 +67,19 @@ class Display
 
     const char *getExtensionString() const;
     const char *getVendorString() const;
-
     EGLNativeDisplayType getDisplayId() const { return mDisplayId; }
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Display);
 
-    Display(EGLNativeDisplayType displayId, EGLint displayType);
+    Display(EGLNativeDisplayType displayId);
+
+    void setAttributes(const AttributeMap &attribMap);
 
-    bool restoreLostDevice();
+    Error restoreLostDevice();
 
     EGLNativeDisplayType mDisplayId;
-    EGLint mRequestedDisplayType;
+    AttributeMap mAttributeMap;
 
     typedef std::set<Surface*> SurfaceSet;
     SurfaceSet mSurfaceSet;
diff --git a/src/3rdparty/angle/src/libEGL/Error.cpp b/src/3rdparty/angle/src/libEGL/Error.cpp
new file mode 100644
index 0000000000..df5f163d32
--- /dev/null
+++ b/src/3rdparty/angle/src/libEGL/Error.cpp
@@ -0,0 +1,48 @@
+//
+// Copyright (c) 2014 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.
+//
+
+// Error.cpp: Implements the egl::Error class which encapsulates an EGL error
+// and optional error message.
+
+#include "libEGL/Error.h"
+
+#include "common/angleutils.h"
+
+#include <cstdarg>
+
+namespace egl
+{
+
+Error::Error(EGLint errorCode)
+    : mCode(errorCode),
+      mMessage()
+{
+}
+
+Error::Error(EGLint errorCode, const char *msg, ...)
+    : mCode(errorCode),
+    mMessage()
+{
+    va_list vararg;
+    va_start(vararg, msg);
+    mMessage = FormatString(msg, vararg);
+    va_end(vararg);
+}
+
+Error::Error(const Error &other)
+    : mCode(other.mCode),
+    mMessage(other.mMessage)
+{
+}
+
+Error &Error::operator=(const Error &other)
+{
+    mCode = other.mCode;
+    mMessage = other.mMessage;
+    return *this;
+}
+
+}
diff --git a/src/3rdparty/angle/src/libEGL/Error.h b/src/3rdparty/angle/src/libEGL/Error.h
new file mode 100644
index 0000000000..71805d2fb7
--- /dev/null
+++ b/src/3rdparty/angle/src/libEGL/Error.h
@@ -0,0 +1,39 @@
+//
+// Copyright (c) 2014 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.
+
+// Error.h: Defines the egl::Error class which encapsulates an EGL error
+// and optional error message.
+
+#ifndef LIBEGL_ERROR_H_
+#define LIBEGL_ERROR_H_
+
+#include <EGL/egl.h>
+
+#include <string>
+
+namespace egl
+{
+
+class Error
+{
+  public:
+    explicit Error(EGLint errorCode);
+    Error(EGLint errorCode, const char *msg, ...);
+    Error(const Error &other);
+    Error &operator=(const Error &other);
+
+    EGLint getCode() const { return mCode; }
+    bool isError() const { return (mCode != EGL_SUCCESS); }
+
+    const std::string &getMessage() const { return mMessage; }
+
+  private:
+    EGLint mCode;
+    std::string mMessage;
+};
+
+}
+
+#endif // LIBEGL_ERROR_H_
diff --git a/src/3rdparty/angle/src/libEGL/Surface.cpp b/src/3rdparty/angle/src/libEGL/Surface.cpp
index fa7996152a..b664a8530e 100644
--- a/src/3rdparty/angle/src/libEGL/Surface.cpp
+++ b/src/3rdparty/angle/src/libEGL/Surface.cpp
@@ -22,23 +22,19 @@
 #include "libEGL/main.h"
 #include "libEGL/Display.h"
 
-#if defined(ANGLE_PLATFORM_WINRT)
-#  include "wrl.h"
-#  include "windows.graphics.display.h"
-#  include "windows.ui.core.h"
-using namespace ABI::Windows::Graphics::Display;
-using namespace ABI::Windows::Foundation;
-using namespace ABI::Windows::UI::Core;
-using namespace Microsoft::WRL;
-#endif
+#include "common/NativeWindow.h"
+
+//TODO(jmadill): phase this out
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 
 namespace egl
 {
 
-Surface::Surface(Display *display, const Config *config, EGLNativeWindowType window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported)
-    : mDisplay(display), mConfig(config), mWindow(window), mPostSubBufferSupported(postSubBufferSupported)
+Surface::Surface(Display *display, const Config *config, EGLNativeWindowType window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported) 
+    : mDisplay(display), mConfig(config), mNativeWindow(window, display->getDisplayId()), mPostSubBufferSupported(postSubBufferSupported)
 {
-    mRenderer = mDisplay->getRenderer();
+    //TODO(jmadill): MANGLE refactor. (note, can't call makeRendererD3D because of dll export issues)
+    mRenderer = static_cast<rx::RendererD3D*>(mDisplay->getRenderer());
     mSwapChain = NULL;
     mShareHandle = NULL;
     mTexture = NULL;
@@ -51,27 +47,19 @@ Surface::Surface(Display *display, const Config *config, EGLNativeWindowType win
     mSwapInterval = -1;
     mWidth = width;
     mHeight = height;
+    mFixedWidth = mWidth;
+    mFixedHeight = mHeight;
     setSwapInterval(1);
     mFixedSize = fixedSize;
-    mSwapFlags = rx::SWAP_NORMAL;
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (mWindow)
-        mWindow->AddRef();
-    mScaleFactor = 1.0;
-    mSizeToken.value = 0;
-    mDpiToken.value = 0;
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-    mOrientationToken.value = 0;
-#   endif
-#endif
 
     subclassWindow();
 }
 
 Surface::Surface(Display *display, const Config *config, HANDLE shareHandle, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureType)
-    : mDisplay(display), mWindow(NULL), mConfig(config), mShareHandle(shareHandle), mWidth(width), mHeight(height), mPostSubBufferSupported(EGL_FALSE)
+    : mDisplay(display), mNativeWindow(NULL, NULL), mConfig(config), mShareHandle(shareHandle), mWidth(width), mHeight(height), mPostSubBufferSupported(EGL_FALSE)
 {
-    mRenderer = mDisplay->getRenderer();
+    //TODO(jmadill): MANGLE refactor. (note, can't call makeRendererD3D because of dll export issues)
+    mRenderer = static_cast<rx::RendererD3D*>(mDisplay->getRenderer());
     mSwapChain = NULL;
     mWindowSubclassed = false;
     mTexture = NULL;
@@ -85,90 +73,33 @@ Surface::Surface(Display *display, const Config *config, HANDLE shareHandle, EGL
     setSwapInterval(1);
     // This constructor is for offscreen surfaces, which are always fixed-size.
     mFixedSize = EGL_TRUE;
-    mSwapFlags = rx::SWAP_NORMAL;
-#if defined(ANGLE_PLATFORM_WINRT)
-    mScaleFactor = 1.0;
-    mSizeToken.value = 0;
-    mDpiToken.value = 0;
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-    mOrientationToken.value = 0;
-#   endif
-#endif
+    mFixedWidth = mWidth;
+    mFixedHeight = mHeight;
 }
 
 Surface::~Surface()
 {
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (mSizeToken.value) {
-        ComPtr<ICoreWindow> coreWindow;
-        HRESULT hr = mWindow->QueryInterface(coreWindow.GetAddressOf());
-        ASSERT(SUCCEEDED(hr));
-
-        hr = coreWindow->remove_SizeChanged(mSizeToken);
-        ASSERT(SUCCEEDED(hr));
-    }
-    if (mDpiToken.value) {
-        ComPtr<IDisplayInformation> displayInformation;
-        HRESULT hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
-        ASSERT(SUCCEEDED(hr));
-
-        hr = displayInformation->remove_DpiChanged(mDpiToken);
-        ASSERT(SUCCEEDED(hr));
-    }
-#   if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
-    if (mOrientationToken.value) {
-        ComPtr<IDisplayInformation> displayInformation;
-        HRESULT hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
-        ASSERT(SUCCEEDED(hr));
-
-        hr = displayInformation->remove_OrientationChanged(mOrientationToken);
-        ASSERT(SUCCEEDED(hr));
-    }
-#   endif
-#endif
     unsubclassWindow();
     release();
 }
 
-bool Surface::initialize()
-{
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (!mFixedSize) {
-        HRESULT hr;
-        ComPtr<IDisplayInformation> displayInformation;
-        hr = mDisplay->getDisplayId()->QueryInterface(displayInformation.GetAddressOf());
-        ASSERT(SUCCEEDED(hr));
-        onDpiChanged(displayInformation.Get(), 0);
-        hr = displayInformation->add_DpiChanged(Callback<ITypedEventHandler<DisplayInformation *, IInspectable *>>(this, &Surface::onDpiChanged).Get(),
-                                                &mDpiToken);
-        ASSERT(SUCCEEDED(hr));
-
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-        onOrientationChanged(displayInformation.Get(), 0);
-        hr = displayInformation->add_OrientationChanged(Callback<ITypedEventHandler<DisplayInformation *, IInspectable *>>(this, &Surface::onOrientationChanged).Get(),
-                                                        &mOrientationToken);
-        ASSERT(SUCCEEDED(hr));
-#   endif
-
-        ComPtr<ICoreWindow> coreWindow;
-        hr = mWindow->QueryInterface(coreWindow.GetAddressOf());
-        ASSERT(SUCCEEDED(hr));
-
-        Rect rect;
-        hr = coreWindow->get_Bounds(&rect);
-        ASSERT(SUCCEEDED(hr));
-        mWidth = rect.Width * mScaleFactor;
-        mHeight = rect.Height * mScaleFactor;
-        hr = coreWindow->add_SizeChanged(Callback<ITypedEventHandler<CoreWindow *, WindowSizeChangedEventArgs *>>(this, &Surface::onSizeChanged).Get(),
-                                         &mSizeToken);
-        ASSERT(SUCCEEDED(hr));
+Error Surface::initialize()
+{
+    if (mNativeWindow.getNativeWindow())
+    {
+        if (!mNativeWindow.initialize())
+        {
+            return Error(EGL_BAD_SURFACE);
+        }
     }
-#endif
 
-    if (!resetSwapChain())
-      return false;
+    Error error = resetSwapChain();
+    if (error.isError())
+    {
+        return error;
+    }
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
 void Surface::release()
@@ -181,85 +112,80 @@ void Surface::release()
         mTexture->releaseTexImage();
         mTexture = NULL;
     }
-
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (mWindow)
-        mWindow->Release();
-#endif
 }
 
-bool Surface::resetSwapChain()
+Error Surface::resetSwapChain()
 {
     ASSERT(!mSwapChain);
 
     int width;
     int height;
 
-#if !defined(ANGLE_PLATFORM_WINRT)
     if (!mFixedSize)
     {
         RECT windowRect;
-        if (!GetClientRect(getWindowHandle(), &windowRect))
+        if (!mNativeWindow.getClientRect(&windowRect))
         {
             ASSERT(false);
 
-            ERR("Could not retrieve the window dimensions");
-            return error(EGL_BAD_SURFACE, false);
+            return Error(EGL_BAD_SURFACE, "Could not retrieve the window dimensions");
         }
 
         width = windowRect.right - windowRect.left;
         height = windowRect.bottom - windowRect.top;
     }
     else
-#endif
     {
         // non-window surface - size is determined at creation
         width = mWidth;
         height = mHeight;
     }
 
-    mSwapChain = mRenderer->createSwapChain(mWindow, mShareHandle,
+    mSwapChain = mRenderer->createSwapChain(mNativeWindow, mShareHandle,
                                             mConfig->mRenderTargetFormat,
                                             mConfig->mDepthStencilFormat);
     if (!mSwapChain)
     {
-        return error(EGL_BAD_ALLOC, false);
+        return Error(EGL_BAD_ALLOC);
     }
 
-    if (!resetSwapChain(width, height))
+    Error error = resetSwapChain(width, height);
+    if (error.isError())
     {
-        delete mSwapChain;
-        mSwapChain = NULL;
-        return false;
+        SafeDelete(mSwapChain);
+        return error;
     }
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
-bool Surface::resizeSwapChain(int backbufferWidth, int backbufferHeight)
+Error Surface::resizeSwapChain(int backbufferWidth, int backbufferHeight)
 {
-    ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0);
     ASSERT(mSwapChain);
 
-    EGLint status = mSwapChain->resize(std::max(1, backbufferWidth), std::max(1, backbufferHeight));
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    backbufferWidth = std::max(1, backbufferWidth);
+    backbufferHeight = std::max(1, backbufferHeight);
+#endif
+    EGLint status = mSwapChain->resize(backbufferWidth, backbufferHeight);
 
     if (status == EGL_CONTEXT_LOST)
     {
         mDisplay->notifyDeviceLost();
-        return false;
+        return Error(status);
     }
     else if (status != EGL_SUCCESS)
     {
-        return error(status, false);
+        return Error(status);
     }
 
     mWidth = backbufferWidth;
     mHeight = backbufferHeight;
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
-bool Surface::resetSwapChain(int backbufferWidth, int backbufferHeight)
+Error Surface::resetSwapChain(int backbufferWidth, int backbufferHeight)
 {
     ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0);
     ASSERT(mSwapChain);
@@ -269,69 +195,71 @@ bool Surface::resetSwapChain(int backbufferWidth, int backbufferHeight)
     if (status == EGL_CONTEXT_LOST)
     {
         mRenderer->notifyDeviceLost();
-        return false;
+        return Error(status);
     }
     else if (status != EGL_SUCCESS)
     {
-        return error(status, false);
+        return Error(status);
     }
 
     mWidth = backbufferWidth;
     mHeight = backbufferHeight;
     mSwapIntervalDirty = false;
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
-bool Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+Error Surface::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
 {
     if (!mSwapChain)
     {
-        return true;
+        return Error(EGL_SUCCESS);
     }
 
-    if (x + width > mWidth)
+    if (x + width > abs(mWidth))
     {
-        width = mWidth - x;
+        width = abs(mWidth) - x;
     }
 
-    if (y + height > mHeight)
+    if (y + height > abs(mHeight))
     {
-        height = mHeight - y;
+        height = abs(mHeight) - y;
     }
 
     if (width == 0 || height == 0)
     {
-        return true;
+        return Error(EGL_SUCCESS);
     }
 
-    EGLint status = mSwapChain->swapRect(x, y, width, height, mSwapFlags);
+    ASSERT(width > 0);
+    ASSERT(height > 0);
+
+    EGLint status = mSwapChain->swapRect(x, y, width, height);
 
     if (status == EGL_CONTEXT_LOST)
     {
         mRenderer->notifyDeviceLost();
-        return false;
+        return Error(status);
     }
     else if (status != EGL_SUCCESS)
     {
-        return error(status, false);
+        return Error(status);
     }
 
     checkForOutOfDateSwapChain();
 
-    return true;
+    return Error(EGL_SUCCESS);
 }
 
 EGLNativeWindowType Surface::getWindowHandle()
 {
-    return mWindow;
+    return mNativeWindow.getNativeWindow();
 }
 
-
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
 #define kSurfaceProperty _TEXT("Egl::SurfaceOwner")
 #define kParentWndProc _TEXT("Egl::SurfaceParentWndProc")
 
-#if !defined(ANGLE_PLATFORM_WINRT)
 static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
   if (message == WM_SIZE)
@@ -349,45 +277,50 @@ static LRESULT CALLBACK SurfaceWindowProc(HWND hwnd, UINT message, WPARAM wparam
 
 void Surface::subclassWindow()
 {
-#if !defined(ANGLE_PLATFORM_WINRT)
-    if (!mWindow)
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    HWND window = mNativeWindow.getNativeWindow();
+    if (!window)
     {
         return;
     }
 
     DWORD processId;
-    DWORD threadId = GetWindowThreadProcessId(mWindow, &processId);
+    DWORD threadId = GetWindowThreadProcessId(window, &processId);
     if (processId != GetCurrentProcessId() || threadId != GetCurrentThreadId())
     {
         return;
     }
 
     SetLastError(0);
-    LONG_PTR oldWndProc = SetWindowLongPtr(mWindow, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(SurfaceWindowProc));
+    LONG_PTR oldWndProc = SetWindowLongPtr(window, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(SurfaceWindowProc));
     if(oldWndProc == 0 && GetLastError() != ERROR_SUCCESS)
     {
         mWindowSubclassed = false;
         return;
     }
 
-    SetProp(mWindow, kSurfaceProperty, reinterpret_cast<HANDLE>(this));
-    SetProp(mWindow, kParentWndProc, reinterpret_cast<HANDLE>(oldWndProc));
+    SetProp(window, kSurfaceProperty, reinterpret_cast<HANDLE>(this));
+    SetProp(window, kParentWndProc, reinterpret_cast<HANDLE>(oldWndProc));
     mWindowSubclassed = true;
-#else
-    mWindowSubclassed = false;
 #endif
 }
 
 void Surface::unsubclassWindow()
 {
-#if !defined(ANGLE_PLATFORM_WINRT)
     if(!mWindowSubclassed)
     {
         return;
     }
 
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    HWND window = mNativeWindow.getNativeWindow();
+    if (!window)
+    {
+        return;
+    }
+
     // un-subclass
-    LONG_PTR parentWndFunc = reinterpret_cast<LONG_PTR>(GetProp(mWindow, kParentWndProc));
+    LONG_PTR parentWndFunc = reinterpret_cast<LONG_PTR>(GetProp(window, kParentWndProc));
 
     // Check the windowproc is still SurfaceWindowProc.
     // If this assert fails, then it is likely the application has subclassed the
@@ -396,29 +329,28 @@ void Surface::unsubclassWindow()
     // EGL context, or to unsubclass before destroying the EGL context.
     if(parentWndFunc)
     {
-        LONG_PTR prevWndFunc = SetWindowLongPtr(mWindow, GWLP_WNDPROC, parentWndFunc);
+        LONG_PTR prevWndFunc = SetWindowLongPtr(window, GWLP_WNDPROC, parentWndFunc);
         UNUSED_ASSERTION_VARIABLE(prevWndFunc);
         ASSERT(prevWndFunc == reinterpret_cast<LONG_PTR>(SurfaceWindowProc));
     }
 
-    RemoveProp(mWindow, kSurfaceProperty);
-    RemoveProp(mWindow, kParentWndProc);
-    mWindowSubclassed = false;
+    RemoveProp(window, kSurfaceProperty);
+    RemoveProp(window, kParentWndProc);
 #endif
+    mWindowSubclassed = false;
 }
 
 bool Surface::checkForOutOfDateSwapChain()
 {
+    RECT client;
     int clientWidth = getWidth();
     int clientHeight = getHeight();
     bool sizeDirty = false;
-#if !defined(ANGLE_PLATFORM_WINRT)
-    if (!mFixedSize && !IsIconic(getWindowHandle()))
+    if (!mFixedSize && !mNativeWindow.isIconic())
     {
-        RECT client;
         // The window is automatically resized to 150x22 when it's minimized, but the swapchain shouldn't be resized
         // because that's not a useful size to render to.
-        if (!GetClientRect(getWindowHandle(), &client))
+        if (!mNativeWindow.getClientRect(&client))
         {
             ASSERT(false);
             return false;
@@ -429,7 +361,13 @@ bool Surface::checkForOutOfDateSwapChain()
         clientHeight = client.bottom - client.top;
         sizeDirty = clientWidth != getWidth() || clientHeight != getHeight();
     }
-#endif
+
+    if (mFixedSize && (mWidth != mFixedWidth || mHeight != mFixedHeight))
+    {
+        clientWidth = mFixedWidth;
+        clientHeight = mFixedHeight;
+        sizeDirty = true;
+    }
 
     bool wasDirty = (mSwapIntervalDirty || sizeDirty);
 
@@ -455,17 +393,17 @@ bool Surface::checkForOutOfDateSwapChain()
     return false;
 }
 
-bool Surface::swap()
+Error Surface::swap()
 {
-    return swapRect(0, 0, mWidth, mHeight);
+    return swapRect(0, 0, abs(mWidth), abs(mHeight));
 }
 
-bool Surface::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+Error Surface::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height)
 {
     if (!mPostSubBufferSupported)
     {
         // Spec is not clear about how this should be handled.
-        return true;
+        return Error(EGL_SUCCESS);
     }
 
     return swapRect(x, y, width, height);
@@ -550,77 +488,18 @@ EGLint Surface::isFixedSize() const
     return mFixedSize;
 }
 
-EGLenum Surface::getFormat() const
+void Surface::setFixedWidth(EGLint width)
 {
-    return mConfig->mRenderTargetFormat;
+    mFixedWidth = width;
 }
 
-#if defined(ANGLE_PLATFORM_WINRT)
-
-HRESULT Surface::onSizeChanged(ICoreWindow *, IWindowSizeChangedEventArgs *args)
+void Surface::setFixedHeight(EGLint height)
 {
-    HRESULT hr;
-    Size size;
-    hr = args->get_Size(&size);
-    ASSERT(SUCCEEDED(hr));
-
-    resizeSwapChain(std::floor(size.Width * mScaleFactor + 0.5),
-                    std::floor(size.Height * mScaleFactor + 0.5));
-
-    if (static_cast<egl::Surface*>(getCurrentDrawSurface()) == this)
-    {
-        glMakeCurrent(glGetCurrentContext(), static_cast<egl::Display*>(getCurrentDisplay()), this);
-    }
-
-    return S_OK;
-}
-
-HRESULT Surface::onDpiChanged(IDisplayInformation *displayInformation, IInspectable *)
-{
-    HRESULT hr;
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-    ComPtr<IDisplayInformation2> displayInformation2;
-    hr = displayInformation->QueryInterface(displayInformation2.GetAddressOf());
-    ASSERT(SUCCEEDED(hr));
-
-    hr = displayInformation2->get_RawPixelsPerViewPixel(&mScaleFactor);
-    ASSERT(SUCCEEDED(hr));
-#   else
-    ResolutionScale resolutionScale;
-    hr = displayInformation->get_ResolutionScale(&resolutionScale);
-    ASSERT(SUCCEEDED(hr));
-
-    mScaleFactor = double(resolutionScale) / 100.0;
-#   endif
-    return S_OK;
-}
-
-#   if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
-HRESULT Surface::onOrientationChanged(IDisplayInformation *displayInformation, IInspectable *)
-{
-    HRESULT hr;
-    DisplayOrientations orientation;
-    hr = displayInformation->get_CurrentOrientation(&orientation);
-    ASSERT(SUCCEEDED(hr));
-    switch (orientation) {
-    default:
-    case DisplayOrientations_Portrait:
-        mSwapFlags = rx::SWAP_NORMAL;
-        break;
-    case DisplayOrientations_Landscape:
-        mSwapFlags = rx::SWAP_ROTATE_90;
-        break;
-    case DisplayOrientations_LandscapeFlipped:
-        mSwapFlags = rx::SWAP_ROTATE_270;
-        break;
-    case DisplayOrientations_PortraitFlipped:
-        mSwapFlags = rx::SWAP_ROTATE_180;
-        break;
-    }
-    return S_OK;
+    mFixedHeight = height;
 }
-#   endif
-
-#endif
 
+EGLenum Surface::getFormat() const
+{
+    return mConfig->mRenderTargetFormat;
+}
 }
diff --git a/src/3rdparty/angle/src/libEGL/Surface.h b/src/3rdparty/angle/src/libEGL/Surface.h
index ebffce8fed..46382d06e1 100644
--- a/src/3rdparty/angle/src/libEGL/Surface.h
+++ b/src/3rdparty/angle/src/libEGL/Surface.h
@@ -11,23 +11,12 @@
 #ifndef LIBEGL_SURFACE_H_
 #define LIBEGL_SURFACE_H_
 
+#include "libEGL/Error.h"
+
 #include <EGL/egl.h>
 
 #include "common/angleutils.h"
-
-#if defined(ANGLE_PLATFORM_WINRT)
-#include <EventToken.h>
-namespace ABI { namespace Windows {
-    namespace UI { namespace Core {
-        struct ICoreWindow;
-        struct IWindowSizeChangedEventArgs;
-    } }
-    namespace Graphics { namespace Display {
-        struct IDisplayInformation;
-    } }
-} }
-struct IInspectable;
-#endif
+#include "common/NativeWindow.h"
 
 namespace gl
 {
@@ -35,8 +24,8 @@ class Texture2D;
 }
 namespace rx
 {
-class Renderer;
 class SwapChain;
+class RendererD3D; //TODO(jmadill): remove this
 }
 
 namespace egl
@@ -52,13 +41,13 @@ class Surface
 
     virtual ~Surface();
 
-    bool initialize();
+    Error initialize();
     void release();
-    bool resetSwapChain();
+    Error resetSwapChain();
 
     EGLNativeWindowType getWindowHandle();
-    bool swap();
-    bool postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height);
+    Error swap();
+    Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height);
 
     virtual EGLint isPostSubBufferSupported() const;
 
@@ -81,35 +70,31 @@ class Surface
     virtual gl::Texture2D *getBoundTexture() const;
 
     EGLint isFixedSize() const;
+    void setFixedWidth(EGLint width);
+    void setFixedHeight(EGLint height);
 
-private:
+  private:
     DISALLOW_COPY_AND_ASSIGN(Surface);
 
-#if defined(ANGLE_PLATFORM_WINRT)
-    HRESULT onSizeChanged(ABI::Windows::UI::Core::ICoreWindow *, ABI::Windows::UI::Core::IWindowSizeChangedEventArgs *);
-    HRESULT onDpiChanged(ABI::Windows::Graphics::Display::IDisplayInformation *, IInspectable *);
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-    HRESULT onOrientationChanged(ABI::Windows::Graphics::Display::IDisplayInformation *, IInspectable *);
-#   endif
-#endif
-
     Display *const mDisplay;
-    rx::Renderer *mRenderer;
+    rx::RendererD3D *mRenderer;
 
     HANDLE mShareHandle;
     rx::SwapChain *mSwapChain;
 
     void subclassWindow();
     void unsubclassWindow();
-    bool resizeSwapChain(int backbufferWidth, int backbufferHeight);
-    bool resetSwapChain(int backbufferWidth, int backbufferHeight);
-    bool swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
+    Error resizeSwapChain(int backbufferWidth, int backbufferHeight);
+    Error resetSwapChain(int backbufferWidth, int backbufferHeight);
+    Error swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
 
-    const EGLNativeWindowType mWindow;            // Window that the surface is created for.
+    rx::NativeWindow mNativeWindow;   // Handler for the Window that the surface is created for.
     bool mWindowSubclassed;        // Indicates whether we successfully subclassed mWindow for WM_RESIZE hooking
     const egl::Config *mConfig;    // EGL config surface was created with
     EGLint mHeight;                // Height of surface
     EGLint mWidth;                 // Width of surface
+    EGLint mFixedHeight;         // Pending height of the surface
+    EGLint mFixedWidth;          // Pending width of the surface
 //  EGLint horizontalResolution;   // Horizontal dot pitch
 //  EGLint verticalResolution;     // Vertical dot pitch
 //  EGLBoolean largestPBuffer;     // If true, create largest pbuffer possible
@@ -126,18 +111,9 @@ private:
     EGLint mSwapInterval;
     EGLint mPostSubBufferSupported;
     EGLint mFixedSize;
-    EGLint mSwapFlags;
 
     bool mSwapIntervalDirty;
     gl::Texture2D *mTexture;
-#if defined(ANGLE_PLATFORM_WINRT)
-    double mScaleFactor;
-    EventRegistrationToken mSizeToken;
-    EventRegistrationToken mDpiToken;
-#   if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
-    EventRegistrationToken mOrientationToken;
-#   endif
-#endif
 };
 }
 
diff --git a/src/3rdparty/angle/src/libEGL/libEGL.cpp b/src/3rdparty/angle/src/libEGL/libEGL.cpp
index c2e0fd6d3d..68399d63a4 100644
--- a/src/3rdparty/angle/src/libEGL/libEGL.cpp
+++ b/src/3rdparty/angle/src/libEGL/libEGL.cpp
@@ -13,7 +13,6 @@
 
 #include "common/debug.h"
 #include "common/version.h"
-#include "common/platform.h"
 #include "libGLESv2/Context.h"
 #include "libGLESv2/Texture.h"
 #include "libGLESv2/main.h"
@@ -26,16 +25,20 @@
 #include "libEGL/Display.h"
 #include "libEGL/Surface.h"
 
+#include "common/NativeWindow.h"
+
 bool validateDisplay(egl::Display *display)
 {
     if (display == EGL_NO_DISPLAY)
     {
-        return egl::error(EGL_BAD_DISPLAY, false);
+        recordError(egl::Error(EGL_BAD_DISPLAY));
+        return false;
     }
 
     if (!display->isInitialized())
     {
-        return egl::error(EGL_NOT_INITIALIZED, false);
+        recordError(egl::Error(EGL_NOT_INITIALIZED));
+        return false;
     }
 
     return true;
@@ -50,7 +53,8 @@ bool validateConfig(egl::Display *display, EGLConfig config)
 
     if (!display->isValidConfig(config))
     {
-        return egl::error(EGL_BAD_CONFIG, false);
+        recordError(egl::Error(EGL_BAD_CONFIG));
+        return false;
     }
 
     return true;
@@ -65,7 +69,8 @@ bool validateContext(egl::Display *display, gl::Context *context)
 
     if (!display->isValidContext(context))
     {
-        return egl::error(EGL_BAD_CONTEXT, false);
+        recordError(egl::Error(EGL_BAD_CONTEXT));
+        return false;
     }
 
     return true;
@@ -80,7 +85,8 @@ bool validateSurface(egl::Display *display, egl::Surface *surface)
 
     if (!display->isValidSurface(surface))
     {
-        return egl::error(EGL_BAD_SURFACE, false);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return false;
     }
 
     return true;
@@ -93,12 +99,7 @@ EGLint __stdcall eglGetError(void)
     EVENT("()");
 
     EGLint error = egl::getCurrentError();
-
-    if (error != EGL_SUCCESS)
-    {
-        egl::setCurrentError(EGL_SUCCESS);
-    }
-
+    recordError(egl::Error(EGL_SUCCESS));
     return error;
 }
 
@@ -106,7 +107,7 @@ EGLDisplay __stdcall eglGetDisplay(EGLNativeDisplayType display_id)
 {
     EVENT("(EGLNativeDisplayType display_id = 0x%0.8p)", display_id);
 
-    return egl::Display::getDisplay(display_id, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE);
+    return egl::Display::getDisplay(display_id, egl::AttributeMap());
 }
 
 EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
@@ -120,19 +121,26 @@ EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_dis
         break;
 
       default:
-        return egl::error(EGL_BAD_CONFIG, EGL_NO_DISPLAY);
+        recordError(egl::Error(EGL_BAD_CONFIG));
+        return EGL_NO_DISPLAY;
     }
 
     EGLNativeDisplayType displayId = static_cast<EGLNativeDisplayType>(native_display);
-#if !defined(ANGLE_PLATFORM_WINRT)
+
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
     // Validate the display device context
     if (WindowFromDC(displayId) == NULL)
     {
-        return egl::success(EGL_NO_DISPLAY);
+        recordError(egl::Error(EGL_SUCCESS));
+        return EGL_NO_DISPLAY;
     }
 #endif
 
-    EGLint requestedDisplayType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    EGLint platformType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+    bool majorVersionSpecified = false;
+    bool minorVersionSpecified = false;
+    bool requestedWARP = false;
+
     if (attrib_list)
     {
         for (const EGLint *curAttrib = attrib_list; curAttrib[0] != EGL_NONE; curAttrib += 2)
@@ -140,7 +148,69 @@ EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_dis
             switch (curAttrib[0])
             {
               case EGL_PLATFORM_ANGLE_TYPE_ANGLE:
-                requestedDisplayType = curAttrib[1];
+                switch (curAttrib[1])
+                {
+                  case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
+                    break;
+
+                  case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
+                  case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
+                    if (!egl::Display::supportsPlatformD3D())
+                    {
+                        recordError(egl::Error(EGL_SUCCESS));
+                        return EGL_NO_DISPLAY;
+                    }
+                    break;
+
+                  case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+                  case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
+                    if (!egl::Display::supportsPlatformOpenGL())
+                    {
+                        recordError(egl::Error(EGL_SUCCESS));
+                        return EGL_NO_DISPLAY;
+                    }
+                    break;
+
+                  default:
+                    recordError(egl::Error(EGL_SUCCESS));
+                    return EGL_NO_DISPLAY;
+                }
+                platformType = curAttrib[1];
+                break;
+
+              case EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE:
+                if (curAttrib[1] != EGL_DONT_CARE)
+                {
+                    majorVersionSpecified = true;
+                }
+                break;
+
+              case EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE:
+                if (curAttrib[1] != EGL_DONT_CARE)
+                {
+                    minorVersionSpecified = true;
+                }
+                break;
+
+              case EGL_PLATFORM_ANGLE_USE_WARP_ANGLE:
+                if (!egl::Display::supportsPlatformD3D())
+                {
+                    recordError(egl::Error(EGL_SUCCESS));
+                    return EGL_NO_DISPLAY;
+                }
+
+                switch (curAttrib[1])
+                {
+                  case EGL_FALSE:
+                  case EGL_TRUE:
+                    break;
+
+                  default:
+                    recordError(egl::Error(EGL_SUCCESS));
+                    return EGL_NO_DISPLAY;
+                }
+
+                requestedWARP = (curAttrib[1] == EGL_TRUE);
                 break;
 
               default:
@@ -149,33 +219,20 @@ EGLDisplay __stdcall eglGetPlatformDisplayEXT(EGLenum platform, void *native_dis
         }
     }
 
-    switch (requestedDisplayType)
+    if (!majorVersionSpecified && minorVersionSpecified)
     {
-      case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
-        break;
-
-      case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
-      case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
-      case EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE:
-        if (!egl::Display::supportsPlatformD3D())
-        {
-            return egl::success(EGL_NO_DISPLAY);
-        }
-        break;
-
-      case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
-      case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
-        if (!egl::Display::supportsPlatformOpenGL())
-        {
-            return egl::success(EGL_NO_DISPLAY);
-        }
-        break;
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_NO_DISPLAY;
+    }
 
-      default:
-        return egl::success(EGL_NO_DISPLAY);
+    if (platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE && requestedWARP)
+    {
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_NO_DISPLAY;
     }
 
-    return egl::Display::getDisplay(displayId, requestedDisplayType);
+    recordError(egl::Error(EGL_SUCCESS));
+    return egl::Display::getDisplay(displayId, egl::AttributeMap(attrib_list));
 }
 
 EGLBoolean __stdcall eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
@@ -185,20 +242,24 @@ EGLBoolean __stdcall eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 
     if (dpy == EGL_NO_DISPLAY)
     {
-        return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_DISPLAY));
+        return EGL_FALSE;
     }
 
     egl::Display *display = static_cast<egl::Display*>(dpy);
 
-    if (!display->initialize())
+    egl::Error error = display->initialize();
+    if (error.isError())
     {
-        return egl::error(EGL_NOT_INITIALIZED, EGL_FALSE);
+        recordError(error);
+        return EGL_FALSE;
     }
 
     if (major) *major = 1;
     if (minor) *minor = 4;
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglTerminate(EGLDisplay dpy)
@@ -207,14 +268,16 @@ EGLBoolean __stdcall eglTerminate(EGLDisplay dpy)
 
     if (dpy == EGL_NO_DISPLAY)
     {
-        return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_DISPLAY));
+        return EGL_FALSE;
     }
 
     egl::Display *display = static_cast<egl::Display*>(dpy);
 
     display->terminate();
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 const char *__stdcall eglQueryString(EGLDisplay dpy, EGLint name)
@@ -227,19 +290,28 @@ const char *__stdcall eglQueryString(EGLDisplay dpy, EGLint name)
         return NULL;
     }
 
+    const char *result;
     switch (name)
     {
       case EGL_CLIENT_APIS:
-        return egl::success("OpenGL_ES");
+        result = "OpenGL_ES";
+        break;
       case EGL_EXTENSIONS:
-        return egl::success(egl::Display::getExtensionString(display));
+        result = egl::Display::getExtensionString(display);
+        break;
       case EGL_VENDOR:
-        return egl::success(display->getVendorString());
+        result = display->getVendorString();
+        break;
       case EGL_VERSION:
-        return egl::success("1.4 (ANGLE " ANGLE_VERSION_STRING ")");
+        result = "1.4 (ANGLE " ANGLE_VERSION_STRING ")";
+        break;
       default:
-        return egl::error(EGL_BAD_PARAMETER, (const char*)NULL);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return NULL;
     }
+
+    recordError(egl::Error(EGL_SUCCESS));
+    return result;
 }
 
 EGLBoolean __stdcall eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
@@ -257,17 +329,20 @@ EGLBoolean __stdcall eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint co
 
     if (!num_config)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     const EGLint attribList[] =    {EGL_NONE};
 
     if (!display->getConfigs(configs, attribList, config_size, num_config))
     {
-        return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_FALSE;
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
@@ -285,7 +360,8 @@ EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
 
     if (!num_config)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     const EGLint attribList[] =    {EGL_NONE};
@@ -297,7 +373,8 @@ EGLBoolean __stdcall eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
 
     display->getConfigs(configs, attrib_list, config_size, num_config);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
@@ -314,10 +391,12 @@ EGLBoolean __stdcall eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint
 
     if (!display->getConfigAttrib(config, attribute, value))
     {
-        return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_FALSE;
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list)
@@ -332,16 +411,21 @@ EGLSurface __stdcall eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EG
         return EGL_NO_SURFACE;
     }
 
-#if !defined(ANGLE_PLATFORM_WINRT)
-    HWND window = (HWND)win;
+    if (!rx::IsValidEGLNativeWindowType(win))
+    {
+        recordError(egl::Error(EGL_BAD_NATIVE_WINDOW));
+        return EGL_NO_SURFACE;
+    }
 
-    if (!IsWindow(window))
+    EGLSurface surface = EGL_NO_SURFACE;
+    egl::Error error = display->createWindowSurface(win, config, attrib_list, &surface);
+    if (error.isError())
     {
-        return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
+        recordError(error);
+        return EGL_NO_SURFACE;
     }
-#endif
 
-    return display->createWindowSurface(win, config, attrib_list);
+    return surface;
 }
 
 EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
@@ -356,7 +440,15 @@ EGLSurface __stdcall eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, c
         return EGL_NO_SURFACE;
     }
 
-    return display->createOffscreenSurface(config, NULL, attrib_list);
+    EGLSurface surface = EGL_NO_SURFACE;
+    egl::Error error = display->createOffscreenSurface(config, NULL, attrib_list, &surface);
+    if (error.isError())
+    {
+        recordError(error);
+        return EGL_NO_SURFACE;
+    }
+
+    return surface;
 }
 
 EGLSurface __stdcall eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
@@ -373,7 +465,8 @@ EGLSurface __stdcall eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EG
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(EGL_NO_SURFACE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_NO_SURFACE;
 }
 
 EGLBoolean __stdcall eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
@@ -390,12 +483,14 @@ EGLBoolean __stdcall eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 
     if (surface == EGL_NO_SURFACE)
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
     display->destroySurface((egl::Surface*)surface);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
@@ -413,7 +508,8 @@ EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint
 
     if (surface == EGL_NO_SURFACE)
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
     switch (attribute)
@@ -473,10 +569,12 @@ EGLBoolean __stdcall eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint
         *value = eglSurface->isFixedSize();
         break;
       default:
-        return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_FALSE;
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value)
@@ -498,7 +596,8 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
 
             if (surface == EGL_NO_SURFACE)
             {
-                return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+                recordError(egl::Error(EGL_BAD_SURFACE));
+                return EGL_FALSE;
             }
 
             rx::SwapChain *swapchain = eglSurface->getSwapChain();
@@ -522,7 +621,8 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
 
             if (renderer->getMajorShaderModel() < 4)
             {
-                return egl::error(EGL_BAD_CONTEXT, EGL_FALSE);
+                recordError(egl::Error(EGL_BAD_CONTEXT));
+                return EGL_FALSE;
             }
 
             *value = static_cast<rx::Renderer11*>(renderer)->getDevice();
@@ -530,10 +630,12 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
         break;
 #endif
       default:
-        return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+        return EGL_FALSE;
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglBindAPI(EGLenum api)
@@ -544,16 +646,19 @@ EGLBoolean __stdcall eglBindAPI(EGLenum api)
     {
       case EGL_OPENGL_API:
       case EGL_OPENVG_API:
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);   // Not supported by this implementation
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;   // Not supported by this implementation
       case EGL_OPENGL_ES_API:
         break;
       default:
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     egl::setCurrentAPI(api);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLenum __stdcall eglQueryAPI(void)
@@ -562,7 +667,8 @@ EGLenum __stdcall eglQueryAPI(void)
 
     EGLenum API = egl::getCurrentAPI();
 
-    return egl::success(API);
+    recordError(egl::Error(EGL_SUCCESS));
+    return API;
 }
 
 EGLBoolean __stdcall eglWaitClient(void)
@@ -571,7 +677,8 @@ EGLBoolean __stdcall eglWaitClient(void)
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(0);
+    recordError(egl::Error(EGL_SUCCESS));
+    return 0;
 }
 
 EGLBoolean __stdcall eglReleaseThread(void)
@@ -580,7 +687,8 @@ EGLBoolean __stdcall eglReleaseThread(void)
 
     eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLSurface __stdcall eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
@@ -598,10 +706,19 @@ EGLSurface __stdcall eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum bu
 
     if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE || !buffer)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_NO_SURFACE;
+    }
+
+    EGLSurface surface = EGL_NO_SURFACE;
+    egl::Error error = display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list, &surface);
+    if (error.isError())
+    {
+        recordError(error);
+        return EGL_NO_SURFACE;
     }
 
-    return display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list);
+    return surface;
 }
 
 EGLBoolean __stdcall eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
@@ -617,9 +734,30 @@ EGLBoolean __stdcall eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint
         return EGL_FALSE;
     }
 
+    switch (attribute)
+    {
+    case EGL_WIDTH:
+        if (!eglSurface->isFixedSize() || !value) {
+            recordError(egl::Error(EGL_BAD_PARAMETER));
+            return EGL_FALSE;
+        }
+        eglSurface->setFixedWidth(value);
+        return EGL_TRUE;
+    case EGL_HEIGHT:
+        if (!eglSurface->isFixedSize() || !value) {
+            recordError(egl::Error(EGL_BAD_PARAMETER));
+            return EGL_FALSE;
+        }
+        eglSurface->setFixedHeight(value);
+        return EGL_TRUE;
+    default:
+        break;
+    }
+
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
@@ -636,30 +774,36 @@ EGLBoolean __stdcall eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint
 
     if (buffer != EGL_BACK_BUFFER)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
     if (eglSurface->getBoundTexture())
     {
-        return egl::error(EGL_BAD_ACCESS, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_ACCESS));
+        return EGL_FALSE;
     }
 
     if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
     {
-        return egl::error(EGL_BAD_MATCH, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_MATCH));
+        return EGL_FALSE;
     }
 
     if (!glBindTexImage(eglSurface))
     {
-        return egl::error(EGL_BAD_MATCH, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_MATCH));
+        return EGL_FALSE;
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
@@ -676,17 +820,20 @@ EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
 
     if (buffer != EGL_BACK_BUFFER)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
     if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
     {
-        return egl::error(EGL_BAD_MATCH, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_MATCH));
+        return EGL_FALSE;
     }
 
     gl::Texture2D *texture = eglSurface->getBoundTexture();
@@ -696,7 +843,8 @@ EGLBoolean __stdcall eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
         texture->releaseTexImage();
     }
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglSwapInterval(EGLDisplay dpy, EGLint interval)
@@ -714,12 +862,14 @@ EGLBoolean __stdcall eglSwapInterval(EGLDisplay dpy, EGLint interval)
 
     if (draw_surface == NULL)
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
     draw_surface->setSwapInterval(interval);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
@@ -744,27 +894,38 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte
               case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
                 if (attribute[1] == EGL_TRUE)
                 {
-                    return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);   // Unimplemented
+                    recordError(egl::Error(EGL_BAD_CONFIG));   // Unimplemented
+                    return EGL_NO_CONTEXT;
                     // robust_access = true;
                 }
                 else if (attribute[1] != EGL_FALSE)
-                    return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                {
+                    recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+                    return 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 egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                {
+                    recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+                    return EGL_NO_CONTEXT;
+                }
                 break;
               default:
-                return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                recordError(egl::Error(EGL_BAD_ATTRIBUTE));
+                return EGL_NO_CONTEXT;
             }
         }
     }
 
     if (client_version != 2 && client_version != 3)
     {
-        return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
+        recordError(egl::Error(EGL_BAD_CONFIG));
+        return EGL_NO_CONTEXT;
     }
 
     egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -775,18 +936,21 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte
 
         if (sharedGLContext->isResetNotificationEnabled() != reset_notification)
         {
-            return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
+            recordError(egl::Error(EGL_BAD_MATCH));
+            return EGL_NO_CONTEXT;
         }
 
         if (sharedGLContext->getClientVersion() != client_version)
         {
-            return egl::error(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
+            recordError(egl::Error(EGL_BAD_CONTEXT));
+            return EGL_NO_CONTEXT;
         }
 
         // Can not share contexts between displays
         if (sharedGLContext->getRenderer() != display->getRenderer())
         {
-            return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
+            recordError(egl::Error(EGL_BAD_MATCH));
+            return EGL_NO_CONTEXT;
         }
     }
 
@@ -795,7 +959,16 @@ EGLContext __stdcall eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLConte
         return EGL_NO_CONTEXT;
     }
 
-    return display->createContext(config, client_version, static_cast<gl::Context*>(share_context), reset_notification, robust_access);
+    EGLContext context = EGL_NO_CONTEXT;
+    egl::Error error =  display->createContext(config, client_version, static_cast<gl::Context*>(share_context),
+                                               reset_notification, robust_access, &context);
+    if (error.isError())
+    {
+        recordError(error);
+        return EGL_NO_CONTEXT;
+    }
+
+    return context;
 }
 
 EGLBoolean __stdcall eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
@@ -812,12 +985,14 @@ EGLBoolean __stdcall eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 
     if (ctx == EGL_NO_CONTEXT)
     {
-        return egl::error(EGL_BAD_CONTEXT, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_CONTEXT));
+        return EGL_FALSE;
     }
 
     display->destroyContext(context);
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
@@ -832,7 +1007,8 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
     bool noSurface = (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE);
     if (noContext != noSurface)
     {
-        return egl::error(EGL_BAD_MATCH, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_MATCH));
+        return EGL_FALSE;
     }
 
     if (ctx != EGL_NO_CONTEXT && !validateContext(display, context))
@@ -850,7 +1026,8 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
 
         if (renderer->isDeviceLost())
         {
-            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
+            recordError(egl::Error(EGL_CONTEXT_LOST));
+            return EGL_FALSE;
         }
     }
 
@@ -871,7 +1048,8 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
 
     glMakeCurrent(context, display, static_cast<egl::Surface*>(draw));
 
-    return egl::success(EGL_TRUE);
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLContext __stdcall eglGetCurrentContext(void)
@@ -880,7 +1058,8 @@ EGLContext __stdcall eglGetCurrentContext(void)
 
     EGLContext context = glGetCurrentContext();
 
-    return egl::success(context);
+    recordError(egl::Error(EGL_SUCCESS));
+    return context;
 }
 
 EGLSurface __stdcall eglGetCurrentSurface(EGLint readdraw)
@@ -889,17 +1068,18 @@ EGLSurface __stdcall eglGetCurrentSurface(EGLint readdraw)
 
     if (readdraw == EGL_READ)
     {
-        EGLSurface read = egl::getCurrentReadSurface();
-        return egl::success(read);
+        recordError(egl::Error(EGL_SUCCESS));
+        return egl::getCurrentReadSurface();
     }
     else if (readdraw == EGL_DRAW)
     {
-        EGLSurface draw = egl::getCurrentDrawSurface();
-        return egl::success(draw);
+        recordError(egl::Error(EGL_SUCCESS));
+        return egl::getCurrentDrawSurface();
     }
     else
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_NO_SURFACE;
     }
 }
 
@@ -909,7 +1089,8 @@ EGLDisplay __stdcall eglGetCurrentDisplay(void)
 
     EGLDisplay dpy = egl::getCurrentDisplay();
 
-    return egl::success(dpy);
+    recordError(egl::Error(EGL_SUCCESS));
+    return dpy;
 }
 
 EGLBoolean __stdcall eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
@@ -927,7 +1108,8 @@ EGLBoolean __stdcall eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attr
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(0);
+    recordError(egl::Error(EGL_SUCCESS));
+    return 0;
 }
 
 EGLBoolean __stdcall eglWaitGL(void)
@@ -936,7 +1118,8 @@ EGLBoolean __stdcall eglWaitGL(void)
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(0);
+    recordError(egl::Error(EGL_SUCCESS));
+    return 0;
 }
 
 EGLBoolean __stdcall eglWaitNative(EGLint engine)
@@ -945,7 +1128,8 @@ EGLBoolean __stdcall eglWaitNative(EGLint engine)
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(0);
+    recordError(egl::Error(EGL_SUCCESS));
+    return 0;
 }
 
 EGLBoolean __stdcall eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
@@ -962,20 +1146,25 @@ EGLBoolean __stdcall eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 
     if (display->getRenderer()->isDeviceLost())
     {
-        return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
+        recordError(egl::Error(EGL_CONTEXT_LOST));
+        return EGL_FALSE;
     }
 
     if (surface == EGL_NO_SURFACE)
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
-    if (eglSurface->swap())
+    egl::Error error = eglSurface->swap();
+    if (error.isError())
     {
-        return egl::success(EGL_TRUE);
+        recordError(error);
+        return EGL_FALSE;
     }
 
-    return EGL_FALSE;
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 EGLBoolean __stdcall eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
@@ -992,12 +1181,14 @@ EGLBoolean __stdcall eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativ
 
     if (display->getRenderer()->isDeviceLost())
     {
-        return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
+        recordError(egl::Error(EGL_CONTEXT_LOST));
+        return EGL_FALSE;
     }
 
     UNIMPLEMENTED();   // FIXME
 
-    return egl::success(0);
+    recordError(egl::Error(EGL_SUCCESS));
+    return 0;
 }
 
 EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)
@@ -1006,7 +1197,8 @@ EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLi
 
     if (x < 0 || y < 0 || width < 0 || height < 0)
     {
-        return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_PARAMETER));
+        return EGL_FALSE;
     }
 
     egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -1019,20 +1211,25 @@ EGLBoolean __stdcall eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLi
 
     if (display->getRenderer()->isDeviceLost())
     {
-        return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
+        recordError(egl::Error(EGL_CONTEXT_LOST));
+        return EGL_FALSE;
     }
 
     if (surface == EGL_NO_SURFACE)
     {
-        return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
+        recordError(egl::Error(EGL_BAD_SURFACE));
+        return EGL_FALSE;
     }
 
-    if (eglSurface->postSubBuffer(x, y, width, height))
+    egl::Error error = eglSurface->postSubBuffer(x, y, width, height);
+    if (error.isError())
     {
-        return egl::success(EGL_TRUE);
+        recordError(error);
+        return EGL_FALSE;
     }
 
-    return EGL_FALSE;
+    recordError(egl::Error(EGL_SUCCESS));
+    return EGL_TRUE;
 }
 
 __eglMustCastToProperFunctionPointerType __stdcall eglGetProcAddress(const char *procname)
diff --git a/src/3rdparty/angle/src/libEGL/main.cpp b/src/3rdparty/angle/src/libEGL/main.cpp
index e74737eaba..e88cad775f 100644
--- a/src/3rdparty/angle/src/libEGL/main.cpp
+++ b/src/3rdparty/angle/src/libEGL/main.cpp
@@ -11,9 +11,6 @@
 #include "common/debug.h"
 #include "common/tls.h"
 
-#if defined(ANGLE_PLATFORM_WINRT)
-__declspec(thread)
-#endif
 static TLSIndex currentTLS = TLS_OUT_OF_INDEXES;
 
 namespace egl
@@ -21,12 +18,6 @@ namespace egl
 
 Current *AllocateCurrent()
 {
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (currentTLS == TLS_OUT_OF_INDEXES)
-    {
-        currentTLS = CreateTLSIndex();
-    }
-#endif
     ASSERT(currentTLS != TLS_OUT_OF_INDEXES);
     if (currentTLS == TLS_OUT_OF_INDEXES)
     {
@@ -51,12 +42,6 @@ Current *AllocateCurrent()
 
 void DeallocateCurrent()
 {
-#if defined(ANGLE_PLATFORM_WINRT)
-    if (currentTLS == TLS_OUT_OF_INDEXES)
-    {
-        return;
-    }
-#endif
     Current *current = reinterpret_cast<Current*>(GetTLSValue(currentTLS));
     SafeDelete(current);
     SetTLSValue(currentTLS, NULL);
@@ -72,7 +57,7 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
     {
       case DLL_PROCESS_ATTACH:
         {
-#if defined(ANGLE_ENABLE_TRACE)
+#if defined(ANGLE_ENABLE_DEBUG_TRACE)
             FILE *debug = fopen(TRACE_OUTPUT_FILE, "rt");
 
             if (debug)
@@ -87,15 +72,15 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
             }
 #endif
 
-#if defined(ANGLE_PLATFORM_WINRT) // On WinRT, don't handle TLS from DllMain
-            return DisableThreadLibraryCalls(instance);
-#endif
-
             currentTLS = CreateTLSIndex();
             if (currentTLS == TLS_OUT_OF_INDEXES)
             {
                 return FALSE;
             }
+
+#ifdef ANGLE_ENABLE_DEBUG_ANNOTATIONS
+            gl::InitializeDebugAnnotations();
+#endif
         }
         // Fall through to initialize index
       case DLL_THREAD_ATTACH:
@@ -105,15 +90,17 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
         break;
       case DLL_THREAD_DETACH:
         {
-#if !defined(ANGLE_PLATFORM_WINRT)
             egl::DeallocateCurrent();
-#endif
         }
         break;
       case DLL_PROCESS_DETACH:
         {
             egl::DeallocateCurrent();
             DestroyTLSIndex(currentTLS);
+
+#ifdef ANGLE_ENABLE_DEBUG_ANNOTATIONS
+            gl::UninitializeDebugAnnotations();
+#endif
         }
         break;
       default:
@@ -143,11 +130,11 @@ Current *GetCurrentData()
 #endif
 }
 
-void setCurrentError(EGLint error)
+void recordError(const Error &error)
 {
     Current *current = GetCurrentData();
 
-    current->error = error;
+    current->error = error.getCode();
 }
 
 EGLint getCurrentError()
@@ -213,9 +200,4 @@ EGLSurface getCurrentReadSurface()
     return current->readSurface;
 }
 
-void error(EGLint errorCode)
-{
-    egl::setCurrentError(errorCode);
-}
-
 }
diff --git a/src/3rdparty/angle/src/libEGL/main.h b/src/3rdparty/angle/src/libEGL/main.h
index 07f5b9e675..e5361a4a5e 100644
--- a/src/3rdparty/angle/src/libEGL/main.h
+++ b/src/3rdparty/angle/src/libEGL/main.h
@@ -9,6 +9,8 @@
 #ifndef LIBEGL_MAIN_H_
 #define LIBEGL_MAIN_H_
 
+#include "libEGL/Error.h"
+
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
@@ -23,7 +25,7 @@ struct Current
     EGLSurface readSurface;
 };
 
-void setCurrentError(EGLint error);
+void recordError(const Error &error);
 EGLint getCurrentError();
 
 void setCurrentAPI(EGLenum API);
@@ -38,24 +40,6 @@ EGLSurface getCurrentDrawSurface();
 void setCurrentReadSurface(EGLSurface surface);
 EGLSurface getCurrentReadSurface();
 
-void error(EGLint errorCode);
-
-template<class T>
-const T &error(EGLint errorCode, const T &returnValue)
-{
-    error(errorCode);
-
-    return returnValue;
-}
-
-template<class T>
-const T &success(const T &returnValue)
-{
-    egl::setCurrentError(EGL_SUCCESS);
-
-    return returnValue;
-}
-
 }
 
 #endif  // LIBEGL_MAIN_H_
author	Andrew Knight <andrew.knight@theqtcompany.com>	2014-11-14 10:52:01 +0200
committer	Jani Heikkinen <jani.heikkinen@theqtcompany.com>	2014-11-14 19:01:38 +0100
commit	c6df5fe3ed0f2a722931be098914978cf17a666f (patch)
tree	23abe340dbc427a3afd255c79316f79fef937059 /src/3rdparty/angle/src/libEGL
parent	32db2f425a0b85bc03d7de42d7b44337d0aa16f4 (diff)