Add EGL extensions structs.

src/libANGLE/Caps.cpp

@@ -13,6 +13,14 @@
 #include <algorithm>
 #include <sstream>
 
+static void InsertExtensionString(const std::string &extension, bool supported, std::vector<std::string> *extensionVector)
+{
+    if (supported)
+    {
+        extensionVector->push_back(extension);
+    }
+}
+
 namespace gl
 {
 
@@ -129,14 +137,6 @@ Extensions::Extensions()
 {
 }
 
-static void InsertExtensionString(const std::string &extension, bool supported, std::vector<std::string> *extensionVector)
-{
-    if (supported)
-    {
-        extensionVector->push_back(extension);
-    }
-}
-
 std::vector<std::string> Extensions::getStrings() const
 {
     std::vector<std::string> extensionStrings;
@@ -429,3 +429,59 @@ Caps::Caps()
 }
 
 }
+
+namespace egl
+{
+
+DisplayExtensions::DisplayExtensions()
+    : createContextRobustness(false),
+      d3dShareHandleClientBuffer(false),
+      surfaceD3DTexture2DShareHandle(false),
+      querySurfacePointer(false),
+      windowFixedSize(false),
+      postSubBuffer(false),
+      createContext(false)
+{
+}
+
+std::vector<std::string> DisplayExtensions::getStrings() const
+{
+    std::vector<std::string> extensionStrings;
+
+    //                   | Extension name                                 | Supported flag                | Output vector   |
+    InsertExtensionString("EGL_EXT_create_context_robustness",             createContextRobustness,        &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_d3d_share_handle_client_buffer",      d3dShareHandleClientBuffer,     &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_surface_d3d_texture_2d_share_handle", surfaceD3DTexture2DShareHandle, &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_query_surface_pointer",               querySurfacePointer,            &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_window_fixed_size",                   windowFixedSize,                &extensionStrings);
+    InsertExtensionString("EGL_NV_post_sub_buffer",                        postSubBuffer,                  &extensionStrings);
+    InsertExtensionString("EGL_KHR_create_context",                        createContext,                  &extensionStrings);
+
+    return extensionStrings;
+}
+
+
+ClientExtensions::ClientExtensions()
+    : clientExtensions(false),
+      platformBase(false),
+      platformANGLE(false),
+      platformANGLED3D(false),
+      platformANGLEOpenGL(false)
+{
+}
+
+std::vector<std::string> ClientExtensions::getStrings() const
+{
+    std::vector<std::string> extensionStrings;
+
+    //                   | Extension name                   | Supported flag     | Output vector   |
+    InsertExtensionString("EGL_EXT_client_extensions",       clientExtensions,    &extensionStrings);
+    InsertExtensionString("EGL_EXT_platform_base",           platformBase,        &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_platform_angle",        platformANGLE,       &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_platform_angle_d3d",    platformANGLED3D,    &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_platform_angle_opengl", platformANGLEOpenGL, &extensionStrings);
+
+    return extensionStrings;
+}
+
+}

src/libANGLE/Caps.h

@@ -280,4 +280,61 @@ struct Caps
 
 }
 
+namespace egl
+{
+
+struct DisplayExtensions
+{
+    DisplayExtensions();
+
+    // Generate a vector of supported extension strings
+    std::vector<std::string> getStrings() const;
+
+    // EGL_EXT_create_context_robustness
+    bool createContextRobustness;
+
+    // EGL_ANGLE_d3d_share_handle_client_buffer
+    bool d3dShareHandleClientBuffer;
+
+    // EGL_ANGLE_surface_d3d_texture_2d_share_handle
+    bool surfaceD3DTexture2DShareHandle;
+
+    // EGL_ANGLE_query_surface_pointer
+    bool querySurfacePointer;
+
+    // EGL_ANGLE_window_fixed_size
+    bool windowFixedSize;
+
+    // EGL_NV_post_sub_buffer
+    bool postSubBuffer;
+
+    // EGL_KHR_create_context
+    bool createContext;
+};
+
+struct ClientExtensions
+{
+    ClientExtensions();
+
+    // Generate a vector of supported extension strings
+    std::vector<std::string> getStrings() const;
+
+    // EGL_EXT_client_extensions
+    bool clientExtensions;
+
+    // EGL_EXT_platform_base
+    bool platformBase;
+
+    // EGL_ANGLE_platform_angle
+    bool platformANGLE;
+
+    // EGL_ANGLE_platform_angle_d3d
+    bool platformANGLED3D;
+
+    // EGL_ANGLE_platform_angle_opengl
+    bool platformANGLEOpenGL;
+};
+
+}
+
 #endif // LIBANGLE_CAPS_H_

src/libANGLE/Display.cpp

@@ -233,7 +233,7 @@ Error Display::initialize()
         return Error(EGL_NOT_INITIALIZED);
     }
 
-    initDisplayExtensionString();
+    initDisplayExtensions();
     initVendorString();
 
     return Error(EGL_SUCCESS);
@@ -614,70 +614,69 @@ bool Display::hasExistingWindowSurface(EGLNativeWindowType window)
     return false;
 }
 
-std::string Display::generateClientExtensionString()
+static ClientExtensions GenerateClientExtensions()
 {
-    std::vector<std::string> extensions;
+    ClientExtensions extensions;
 
-    extensions.push_back("EGL_EXT_client_extensions");
+    extensions.clientExtensions = true;
+    extensions.platformBase = true;
+    extensions.platformANGLE = true;
 
-    extensions.push_back("EGL_EXT_platform_base");
-    extensions.push_back("ANGLE_platform_angle");
+#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
+    extensions.platformANGLED3D = true;
+#endif
 
-    if (supportsPlatformD3D())
-    {
-        extensions.push_back("ANGLE_platform_angle_d3d");
-    }
+#if defined(ANGLE_ENABLE_OPENGL)
+    extensions.platformANGLEOpenGL = true;
+#endif
 
-    if (supportsPlatformOpenGL())
-    {
-        extensions.push_back("ANGLE_platform_angle_opengl");
-    }
+    return extensions;
+}
+
+template <typename T>
+static std::string GenerateExtensionsString(const T &extensions)
+{
+    std::vector<std::string> extensionsVector = extensions.getStrings();
 
     std::ostringstream stream;
-    std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " "));
+    std::copy(extensionsVector.begin(), extensionsVector.end(), std::ostream_iterator<std::string>(stream, " "));
     return stream.str();
 }
 
-void Display::initDisplayExtensionString()
+const ClientExtensions &Display::getClientExtensions()
 {
-    std::vector<std::string> extensions;
+    static const ClientExtensions clientExtensions = GenerateClientExtensions();
+    return clientExtensions;
+}
 
-    // Multi-vendor (EXT) extensions
-    extensions.push_back("EGL_EXT_create_context_robustness");
+const std::string &Display::getClientExtensionString()
+{
+    static const std::string clientExtensionsString = GenerateExtensionsString(getClientExtensions());
+    return clientExtensionsString;
+}
+
+void Display::initDisplayExtensions()
+{
+    mDisplayExtensions.createContextRobustness = true;
 
     // ANGLE-specific extensions
     if (mRenderer->getShareHandleSupport())
     {
-        extensions.push_back("EGL_ANGLE_d3d_share_handle_client_buffer");
-        extensions.push_back("EGL_ANGLE_surface_d3d_texture_2d_share_handle");
+        mDisplayExtensions.d3dShareHandleClientBuffer = true;
+        mDisplayExtensions.surfaceD3DTexture2DShareHandle = true;
     }
 
-    extensions.push_back("EGL_ANGLE_query_surface_pointer");
-    extensions.push_back("EGL_ANGLE_window_fixed_size");
+    mDisplayExtensions.querySurfacePointer = true;
+    mDisplayExtensions.windowFixedSize = true;
 
     if (mRenderer->getPostSubBufferSupport())
     {
-        extensions.push_back("EGL_NV_post_sub_buffer");
+        mDisplayExtensions.postSubBuffer = true;
     }
 
-    extensions.push_back("EGL_KHR_create_context");
-
-    std::ostringstream stream;
-    std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " "));
-    mDisplayExtensionString = stream.str();
-}
+    mDisplayExtensions.createContext = true;
 
-const char *Display::getExtensionString(egl::Display *display)
-{
-    if (display != EGL_NO_DISPLAY)
-    {
-        return display->mDisplayExtensionString.c_str();
-    }
-    else
-    {
-        static std::string clientExtensions = generateClientExtensionString();
-        return clientExtensions.c_str();
-    }
+    mDisplayExtensionString = GenerateExtensionsString(mDisplayExtensions);
 }
 
 bool Display::isValidNativeWindow(EGLNativeWindowType window) const
@@ -706,20 +705,6 @@ bool Display::isValidNativeDisplay(EGLNativeDisplayType display) const
 #endif
 }
 
-bool Display::supportsPlatformD3D()
-{
-#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool Display::supportsPlatformOpenGL()
-{
-    return false;
-}
-
 void Display::initVendorString()
 {
     mVendorString = "Google Inc.";
@@ -731,9 +716,19 @@ void Display::initVendorString()
     }
 }
 
-const char *Display::getVendorString() const
+const DisplayExtensions &Display::getExtensions() const
+{
+    return mDisplayExtensions;
+}
+
+const std::string &Display::getExtensionString() const
+{
+    return mDisplayExtensionString;
+}
+
+const std::string &Display::getVendorString() const
 {
-    return mVendorString.c_str();
+    return mVendorString;
 }
 
 }

src/libANGLE/Display.h

@@ -42,10 +42,8 @@ class Display final
 
     static egl::Display *getDisplay(EGLNativeDisplayType displayId, const AttributeMap &attribMap);
 
-    static const char *getExtensionString(egl::Display *display);
-
-    static bool supportsPlatformD3D();
-    static bool supportsPlatformOpenGL();
+    static const ClientExtensions &getClientExtensions();
+    static const std::string &getClientExtensionString();
 
     bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
     bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
@@ -70,8 +68,9 @@ class Display final
 
     void notifyDeviceLost();
 
-    const char *getExtensionString() const;
-    const char *getVendorString() const;
+    const DisplayExtensions &getExtensions() const;
+    const std::string &getExtensionString() const;
+    const std::string &getVendorString() const;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Display);
@@ -82,9 +81,7 @@ class Display final
 
     Error restoreLostDevice();
 
-    static std::string generateClientExtensionString();
-
-    void initDisplayExtensionString();
+    void initDisplayExtensions();
     void initVendorString();
 
     rx::DisplayImpl *mImplementation;
@@ -99,6 +96,7 @@ class Display final
 
     rx::Renderer *mRenderer;
 
+    DisplayExtensions mDisplayExtensions;
     std::string mDisplayExtensionString;
 
     std::string mVendorString;

src/libGLESv2/entry_points_egl.cpp

@@ -177,10 +177,17 @@ const char *EGLAPIENTRY QueryString(EGLDisplay dpy, EGLint name)
         result = "OpenGL_ES";
         break;
       case EGL_EXTENSIONS:
-        result = Display::getExtensionString(display);
+        if (display == EGL_NO_DISPLAY)
+        {
+            result = Display::getClientExtensionString().c_str();
+        }
+        else
+        {
+            result = display->getExtensionString().c_str();
+        }
         break;
       case EGL_VENDOR:
-        result = display->getVendorString();
+        result = display->getVendorString().c_str();
         break;
       case EGL_VERSION:
         result = "1.4 (ANGLE " ANGLE_VERSION_STRING ")";

src/libGLESv2/entry_points_egl_ext.cpp

@@ -145,6 +145,8 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
         return EGL_NO_DISPLAY;
     }
 
+    const ClientExtensions &clientExtensions = Display::getClientExtensions();
+
     EGLint platformType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
     bool majorVersionSpecified = false;
     bool minorVersionSpecified = false;
@@ -164,7 +166,7 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
 
                   case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
                   case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
-                    if (!Display::supportsPlatformD3D())
+                    if (!clientExtensions.platformANGLED3D)
                     {
                         SetGlobalError(Error(EGL_SUCCESS));
                         return EGL_NO_DISPLAY;
@@ -173,7 +175,7 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
 
                   case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
                   case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
-                    if (!Display::supportsPlatformOpenGL())
+                    if (!clientExtensions.platformANGLEOpenGL)
                     {
                         SetGlobalError(Error(EGL_SUCCESS));
                         return EGL_NO_DISPLAY;
@@ -202,7 +204,7 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
                 break;
 
               case EGL_PLATFORM_ANGLE_USE_WARP_ANGLE:
-                if (!Display::supportsPlatformD3D())
+                if (!clientExtensions.platformANGLED3D)
                 {
                     SetGlobalError(Error(EGL_SUCCESS));
                     return EGL_NO_DISPLAY;