dEQP: Add EGL 1.5 getPlatformDisplay.

src/tests/deqp.gypi

@@ -1063,14 +1063,19 @@
             '<(deqp_path)/framework/egl/egluGLContextFactory.cpp',
             '<(deqp_path)/framework/egl/egluGLFunctionLoader.cpp',
             '<(deqp_path)/framework/egl/egluGLUtil.cpp',
-            '<(deqp_path)/framework/egl/egluNativeDisplay.cpp',
+            # TODO(jmadill): Remove override when upstreamed. http://anglebug.com/2564
+            #'<(deqp_path)/framework/egl/egluNativeDisplay.cpp',
+            '<(angle_path)/src/tests/deqp_support/egluNativeDisplay_override.cpp',
+            '<(angle_path)/src/tests/deqp_support/egluNativeDisplay_override.hpp',
             '<(deqp_path)/framework/egl/egluNativePixmap.cpp',
             '<(deqp_path)/framework/egl/egluNativeWindow.cpp',
             '<(deqp_path)/framework/egl/egluPlatform.cpp',
             '<(deqp_path)/framework/egl/egluStaticESLibrary.cpp',
             '<(deqp_path)/framework/egl/egluStrUtil.cpp',
             '<(deqp_path)/framework/egl/egluUnique.cpp',
-            '<(deqp_path)/framework/egl/egluUtil.cpp',
+            # TODO(jmadill): Remove override when upstreamed. http://anglebug.com/2564
+            #'<(deqp_path)/framework/egl/egluUtil.cpp',
+            '<(angle_path)/src/tests/deqp_support/egluUtil_override.cpp',
             '<(deqp_path)/framework/egl/wrapper/eglwDefs.cpp',
             '<(deqp_path)/framework/egl/wrapper/eglwFunctions.cpp',
             '<(deqp_path)/framework/egl/wrapper/eglwLibrary.cpp',

src/tests/deqp_support/egluNativeDisplay_override.cpp

+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Tester Core
+ * ----------------------------------------
+ *
+ * Copyright 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */ /*!
+ * \file
+ * \brief EGL native display abstraction
+ */ /*--------------------------------------------------------------------*/
+
+#include "egluNativeDisplay_override.hpp"
+#include "eglwEnums.hpp"
+
+namespace eglu
+{
+
+using namespace eglw;
+
+// NativeDisplay
+
+NativeDisplay::NativeDisplay(Capability capabilities,
+                             EGLenum platformType,
+                             const char *platformExtension)
+    : m_capabilities(capabilities),
+      m_platformType(platformType),
+      m_platformExtension(platformExtension)
+{
+    DE_ASSERT(platformType != EGL_NONE && platformExtension);
+    DE_ASSERT(capabilities & CAPABILITY_GET_DISPLAY_PLATFORM_EXT);
+}
+
+NativeDisplay::NativeDisplay(Capability capabilities)
+    : m_capabilities(capabilities), m_platformType(EGL_NONE), m_platformExtension("")
+{
+    DE_ASSERT(!(capabilities & CAPABILITY_GET_DISPLAY_PLATFORM_EXT));
+    DE_ASSERT(capabilities & CAPABILITY_GET_DISPLAY_LEGACY);
+}
+
+NativeDisplay::~NativeDisplay(void)
+{
+}
+
+EGLNativeDisplayType NativeDisplay::getLegacyNative(void)
+{
+    // If NativeDisplay claims to support CAPABILITY_GET_DISPLAY_LEGACY then
+    // this method must be implemented.
+    TCU_CHECK_INTERNAL((m_capabilities & CAPABILITY_GET_DISPLAY_LEGACY) == 0);
+    TCU_THROW(NotSupportedError, "eglu::NativeDisplay can't be used with eglGetDisplay()");
+}
+
+void *NativeDisplay::getPlatformNative(void)
+{
+    // If NativeDisplay claims to support CAPABILITY_GET_DISPLAY_PLATFORM then
+    // this method must be implemented.
+    TCU_CHECK_INTERNAL((m_capabilities & CAPABILITY_GET_DISPLAY_PLATFORM_EXT) == 0);
+    TCU_THROW(NotSupportedError,
+              "eglu::NativeDisplay can't be used with eglGetPlatformDisplayEXT()");
+}
+
+const EGLAttrib *NativeDisplay::getPlatformAttributes(void) const
+{
+    // If NativeDisplay claims to support CAPABILITY_GET_DISPLAY_PLATFORM then
+    // this method must be implemented.
+    TCU_CHECK_INTERNAL((m_capabilities & CAPABILITY_GET_DISPLAY_PLATFORM_EXT) == 0);
+    TCU_THROW(NotSupportedError,
+              "eglu::NativeDisplay can't be used with eglGetPlatformDisplayEXT()");
+}
+
+// NativeDisplayFactory
+
+NativeDisplayFactory::NativeDisplayFactory(const std::string &name,
+                                           const std::string &description,
+                                           NativeDisplay::Capability capabilities,
+                                           EGLenum platformType,
+                                           const char *platformExtension)
+    : FactoryBase(name, description),
+      m_capabilities(capabilities),
+      m_platformType(platformType),
+      m_platformExtension(platformExtension)
+{
+    DE_ASSERT(platformType != EGL_NONE && platformExtension);
+    DE_ASSERT(capabilities & NativeDisplay::CAPABILITY_GET_DISPLAY_PLATFORM_EXT);
+}
+
+NativeDisplayFactory::NativeDisplayFactory(const std::string &name,
+                                           const std::string &description,
+                                           NativeDisplay::Capability capabilities)
+    : FactoryBase(name, description),
+      m_capabilities(capabilities),
+      m_platformType(EGL_NONE),
+      m_platformExtension("")
+{
+    DE_ASSERT(!(capabilities & NativeDisplay::CAPABILITY_GET_DISPLAY_PLATFORM_EXT));
+    DE_ASSERT(capabilities & NativeDisplay::CAPABILITY_GET_DISPLAY_LEGACY);
+}
+
+NativeDisplayFactory::~NativeDisplayFactory(void)
+{
+}
+
+}  // eglu

src/tests/deqp_support/egluNativeDisplay_override.hpp

+#ifndef _EGLUNATIVEDISPLAY_HPP
+#define _EGLUNATIVEDISPLAY_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Tester Core
+ * ----------------------------------------
+ *
+ * Copyright 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief EGL native display abstraction
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuFactoryRegistry.hpp"
+#include "egluNativeWindow.hpp"
+#include "egluNativePixmap.hpp"
+#include "eglwDefs.hpp"
+
+#include <string>
+
+namespace eglw
+{
+class Library;
+}
+
+namespace eglu
+{
+
+class NativeDisplay
+{
+public:
+	enum Capability
+	{
+		CAPABILITY_GET_DISPLAY_LEGACY		= (1<<0),	//!< Query EGL display using eglGetDisplay()
+		CAPABILITY_GET_DISPLAY_PLATFORM		= (1<<1),	//!< Query EGL display using eglGetPlatformDisplay()
+		CAPABILITY_GET_DISPLAY_PLATFORM_EXT = (1<<2)	//!< Query EGL display using eglGetPlatformDisplayEXT()
+	};
+
+	virtual								~NativeDisplay				(void);
+
+	virtual const eglw::Library&		getLibrary					(void) const = 0;
+
+	Capability							getCapabilities				(void) const { return m_capabilities; }
+	eglw::EGLenum						getPlatformType				(void) const { return m_platformType; }
+	const char*							getPlatformExtensionName	(void) const { return (m_platformExtension.empty() ? DE_NULL : m_platformExtension.c_str()); }
+
+	//! Get EGLNativeDisplayType that can be used with eglGetDisplay(). Default implementation throws tcu::NotSupportedError().
+	virtual eglw::EGLNativeDisplayType	getLegacyNative				(void);
+
+	//! Return display pointer that can be used with eglGetPlatformDisplay(). Default implementations throw tcu::NotSupportedError()
+	virtual void*						getPlatformNative			(void);
+
+	//! Attributes to pass to eglGetPlatformDisplay(EXT)
+	virtual const eglw::EGLAttrib*		getPlatformAttributes		(void) const;
+
+protected:
+										NativeDisplay				(Capability capabilities, eglw::EGLenum platformType, const char* platformExtension);
+										NativeDisplay				(Capability capabilities);
+
+private:
+										NativeDisplay				(const NativeDisplay&);
+	NativeDisplay&						operator=					(const NativeDisplay&);
+
+	const Capability					m_capabilities;
+	const eglw::EGLenum					m_platformType;				//!< EGL platform type, or EGL_NONE if not supported.
+	const std::string					m_platformExtension;
+};
+
+class NativeDisplayFactory : public tcu::FactoryBase
+{
+public:
+	virtual								~NativeDisplayFactory		(void);
+
+	virtual NativeDisplay*				createDisplay				(const eglw::EGLAttrib* attribList = DE_NULL) const = 0;
+
+	NativeDisplay::Capability			getCapabilities				(void) const { return m_capabilities; }
+	eglw::EGLenum						getPlatformType				(void) const { return m_platformType; }
+	const char*							getPlatformExtensionName	(void) const { return (m_platformExtension.empty() ? DE_NULL : m_platformExtension.c_str()); }
+
+	const NativeWindowFactoryRegistry&	getNativeWindowRegistry		(void) const { return m_nativeWindowRegistry; }
+	const NativePixmapFactoryRegistry&	getNativePixmapRegistry		(void) const { return m_nativePixmapRegistry; }
+
+protected:
+										NativeDisplayFactory		(const std::string& name, const std::string& description, NativeDisplay::Capability capabilities);
+										NativeDisplayFactory		(const std::string& name, const std::string& description, NativeDisplay::Capability capabilities, eglw::EGLenum platformType, const char* platformExtension);
+
+	NativeWindowFactoryRegistry			m_nativeWindowRegistry;
+	NativePixmapFactoryRegistry			m_nativePixmapRegistry;
+
+private:
+										NativeDisplayFactory		(const NativeDisplayFactory&);
+	NativeDisplayFactory&				operator=					(const NativeDisplayFactory&);
+
+	const NativeDisplay::Capability		m_capabilities;
+	const eglw::EGLenum					m_platformType;
+	const std::string					m_platformExtension;
+};
+
+typedef tcu::FactoryRegistry<NativeDisplayFactory> NativeDisplayFactoryRegistry;
+
+} // eglu
+
+#endif // _EGLUNATIVEDISPLAY_HPP

src/tests/deqp_support/tcuANGLENativeDisplayFactory.cpp

@@ -18,6 +18,8 @@
  *
  */
 
+#include "egluNativeDisplay_override.hpp"
+
 #include "tcuANGLENativeDisplayFactory.h"
 
 #include <EGL/egl.h>
@@ -55,7 +57,9 @@ enum
 };
 
 constexpr eglu::NativeDisplay::Capability kDisplayCapabilities =
-    eglu::NativeDisplay::CAPABILITY_GET_DISPLAY_PLATFORM;
+    static_cast<eglu::NativeDisplay::Capability>(
+        eglu::NativeDisplay::CAPABILITY_GET_DISPLAY_PLATFORM |
+        eglu::NativeDisplay::CAPABILITY_GET_DISPLAY_PLATFORM_EXT);
 constexpr eglu::NativePixmap::Capability kBitmapCapabilities =
     eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_LEGACY;
 constexpr eglu::NativeWindow::Capability kWindowCapabilities =