Move eglCreateWindowSurface validation into validationEGL.

src/libANGLE/Display.cpp

@@ -224,59 +224,13 @@ bool Display::getConfigAttrib(const Config *configuration, EGLint attribute, EGL
     return true;
 }
 
-Error Display::createWindowSurface(EGLNativeWindowType window, const Config *configuration, const EGLint *attribList, EGLSurface *outSurface)
+Error Display::createWindowSurface(const Config *configuration, EGLNativeWindowType window, const AttributeMap &attribs,
+                                   Surface **outSurface)
 {
-    EGLint postSubBufferSupported = EGL_FALSE;
-
-    EGLint width = 0;
-    EGLint height = 0;
-    EGLint fixedSize = EGL_FALSE;
-
-    if (attribList)
-    {
-        while (*attribList != EGL_NONE)
-        {
-            switch (attribList[0])
-            {
-              case EGL_RENDER_BUFFER:
-                switch (attribList[1])
-                {
-                  case EGL_BACK_BUFFER:
-                    break;
-                  case EGL_SINGLE_BUFFER:
-                    return Error(EGL_BAD_MATCH);   // Rendering directly to front buffer not supported
-                  default:
-                    return Error(EGL_BAD_ATTRIBUTE);
-                }
-                break;
-              case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
-                postSubBufferSupported = attribList[1];
-                break;
-              case EGL_WIDTH:
-                width = attribList[1];
-                break;
-              case EGL_HEIGHT:
-                height = attribList[1];
-                break;
-              case EGL_FIXED_SIZE_ANGLE:
-                fixedSize = attribList[1];
-                break;
-              case EGL_VG_COLORSPACE:
-                return Error(EGL_BAD_MATCH);
-              case EGL_VG_ALPHA_FORMAT:
-                return Error(EGL_BAD_MATCH);
-              default:
-                return Error(EGL_BAD_ATTRIBUTE);
-            }
-
-            attribList += 2;
-        }
-    }
-
-    if (width < 0 || height < 0)
-    {
-        return Error(EGL_BAD_PARAMETER);
-    }
+    EGLint postSubBufferSupported = attribs.get(EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_FALSE);
+    EGLint width = attribs.get(EGL_WIDTH, 0);
+    EGLint height = attribs.get(EGL_HEIGHT, 0);
+    EGLint fixedSize = attribs.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE);
 
     if (!fixedSize)
     {
@@ -284,11 +238,6 @@ Error Display::createWindowSurface(EGLNativeWindowType window, const Config *con
         height = -1;
     }
 
-    if (hasExistingWindowSurface(window))
-    {
-        return Error(EGL_BAD_ALLOC);
-    }
-
     if (mImplementation->testDeviceLost())
     {
         Error error = restoreLostDevice();

src/libANGLE/Display.h

@@ -49,7 +49,8 @@ class Display final
     std::vector<const Config*> getConfigs(const egl::AttributeMap &attribs) const;
     bool getConfigAttrib(const Config *configuration, EGLint attribute, EGLint *value);
 
-    Error createWindowSurface(EGLNativeWindowType window, const Config *configuration, const EGLint *attribList, EGLSurface *outSurface);
+    Error createWindowSurface(const Config *configuration, EGLNativeWindowType window, const AttributeMap &attribs,
+                              Surface **outSurface);
     Error createOffscreenSurface(const Config *configuration, EGLClientBuffer shareHandle, const EGLint *attribList, EGLSurface *outSurface);
     Error createContext(const Config *configuration, gl::Context *shareContext, const AttributeMap &attribs,
                         gl::Context **outContext);

src/libANGLE/validationEGL.cpp

@@ -206,4 +206,84 @@ Error ValidateCreateContext(Display *display, Config *configuration, gl::Context
     return Error(EGL_SUCCESS);
 }
 
+Error ValidateCreateWindowSurface(Display *display, Config *config, EGLNativeWindowType window,
+                                  const AttributeMap& attributes)
+{
+    Error error = ValidateConfig(display, config);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    if (!display->isValidNativeWindow(window))
+    {
+        return Error(EGL_BAD_NATIVE_WINDOW);
+    }
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+
+    for (AttributeMap::const_iterator attributeIter = attributes.begin(); attributeIter != attributes.end(); attributeIter++)
+    {
+        EGLint attribute = attributeIter->first;
+        EGLint value = attributeIter->second;
+
+        switch (attribute)
+        {
+          case EGL_RENDER_BUFFER:
+            switch (value)
+            {
+              case EGL_BACK_BUFFER:
+                break;
+              case EGL_SINGLE_BUFFER:
+                return Error(EGL_BAD_MATCH);   // Rendering directly to front buffer not supported
+              default:
+                return Error(EGL_BAD_ATTRIBUTE);
+            }
+            break;
+
+          case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
+            if (!displayExtensions.postSubBuffer)
+            {
+                return Error(EGL_BAD_ATTRIBUTE);
+            }
+            break;
+
+          case EGL_WIDTH:
+          case EGL_HEIGHT:
+            if (!displayExtensions.windowFixedSize)
+            {
+                return Error(EGL_BAD_ATTRIBUTE);
+            }
+            if (value < 0)
+            {
+                return Error(EGL_BAD_PARAMETER);
+            }
+            break;
+
+          case EGL_FIXED_SIZE_ANGLE:
+            if (!displayExtensions.windowFixedSize)
+            {
+                return Error(EGL_BAD_ATTRIBUTE);
+            }
+            break;
+
+          case EGL_VG_COLORSPACE:
+            return Error(EGL_BAD_MATCH);
+
+          case EGL_VG_ALPHA_FORMAT:
+            return Error(EGL_BAD_MATCH);
+
+          default:
+            return Error(EGL_BAD_ATTRIBUTE);
+        }
+    }
+
+    if (display->hasExistingWindowSurface(window))
+    {
+        return Error(EGL_BAD_ALLOC);
+    }
+
+    return Error(EGL_SUCCESS);
+}
+
 }

src/libANGLE/validationEGL.h

@@ -36,6 +36,9 @@ Error ValidateContext(const Display *display, gl::Context *context);
 Error ValidateCreateContext(Display *display, Config *configuration, gl::Context *shareContext,
                             const AttributeMap& attributes);
 
+Error ValidateCreateWindowSurface(Display *display, Config *config, EGLNativeWindowType window,
+                                  const AttributeMap& attributes);
+
 }
 
 #endif // LIBANGLE_VALIDATIONEGL_H_

src/libGLESv2/entry_points_egl.cpp

@@ -245,29 +245,24 @@ EGLSurface EGLAPIENTRY CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGL
 
     Display *display = static_cast<Display*>(dpy);
     Config *configuration = static_cast<Config*>(config);
+    AttributeMap attributes(attrib_list);
 
-    Error error = ValidateConfig(display, configuration);
+    Error error = ValidateCreateWindowSurface(display, configuration, win, attributes);
     if (error.isError())
     {
         SetGlobalError(error);
         return EGL_NO_SURFACE;
     }
 
-    if (!display->isValidNativeWindow(win))
-    {
-        SetGlobalError(Error(EGL_BAD_NATIVE_WINDOW));
-        return EGL_NO_SURFACE;
-    }
-
-    EGLSurface surface = EGL_NO_SURFACE;
-    error = display->createWindowSurface(win, configuration, attrib_list, &surface);
+    egl::Surface *surface = nullptr;
+    error = display->createWindowSurface(configuration, win, attributes, &surface);
     if (error.isError())
     {
         SetGlobalError(error);
         return EGL_NO_SURFACE;
     }
 
-    return surface;
+    return static_cast<EGLSurface>(surface);
 }
 
 EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)