GLX: Support X11 pixmaps

src/common/utilities.cpp

@@ -1181,6 +1181,8 @@ const char *GetGenericErrorMessage(EGLint error)
             return "Bad match.";
         case EGL_BAD_NATIVE_WINDOW:
             return "Bad native window.";
+        case EGL_BAD_NATIVE_PIXMAP:
+            return "Bad native pixmap.";
         case EGL_BAD_PARAMETER:
             return "Bad parameter.";
         case EGL_BAD_SURFACE:

src/libANGLE/Caps.cpp

@@ -1392,7 +1392,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_KHR_create_context_no_error",                     createContextNoError,               &extensionStrings);
     InsertExtensionString("EGL_EXT_image_dma_buf_import",                        imageDmaBufImportEXT,               &extensionStrings);
     InsertExtensionString("EGL_EXT_image_dma_buf_import_modifiers",              imageDmaBufImportModifiersEXT,      &extensionStrings);
-
+    InsertExtensionString("EGL_NOK_texture_from_pixmap",                         textureFromPixmapNOK,               &extensionStrings);
     // clang-format on
 
     return extensionStrings;

src/libANGLE/Caps.h

@@ -1082,6 +1082,9 @@ struct DisplayExtensions
 
     // EGL_EXT_image_dma_buf_import_modifiers
     bool imageDmaBufImportModifiersEXT = false;
+
+    // EGL_NOK_texture_from_pixmap
+    bool textureFromPixmapNOK = false;
 };
 
 struct DeviceExtensions

src/libANGLE/Config.cpp

@@ -62,7 +62,8 @@ Config::Config()
       optimalOrientation(0),
       colorComponentType(EGL_COLOR_COMPONENT_TYPE_FIXED_EXT),
       recordable(EGL_FALSE),
-      framebufferTarget(EGL_FALSE)  // TODO: http://anglebug.com/4208
+      framebufferTarget(EGL_FALSE),  // TODO: http://anglebug.com/4208
+      yInverted(EGL_FALSE)
 {}
 
 Config::~Config() {}
@@ -368,6 +369,9 @@ std::vector<const Config *> ConfigSet::filter(const AttributeMap &attributeMap)
                 case EGL_FRAMEBUFFER_TARGET_ANDROID:
                     match = config.framebufferTarget == static_cast<EGLBoolean>(attributeValue);
                     break;
+                case EGL_Y_INVERTED_NOK:
+                    match = config.yInverted == static_cast<EGLBoolean>(attributeValue);
+                    break;
                 default:
                     UNREACHABLE();
             }

src/libANGLE/Config.h

@@ -74,6 +74,9 @@ struct Config
     EGLBoolean framebufferTarget;  // EGL_TRUE if the config supports rendering to a ANativeWindow
                                    // for which the buffers are passed to the HWComposer HAL as a
                                    // framebuffer target layer.
+    EGLBoolean yInverted;  // True if the drawable's framebuffer is y-inverted.  This can be used to
+                           // determine if y-inverted texture coordinates need to be used when
+                           // texturing from this drawable when it is bound to a texture target.
 };
 
 class ConfigSet

src/libANGLE/Display.cpp

@@ -1586,6 +1586,13 @@ Error Display::validateImageClientBuffer(const gl::Context *context,
     return mImplementation->validateImageClientBuffer(context, target, clientBuffer, attribs);
 }
 
+Error Display::valdiatePixmap(Config *config,
+                              EGLNativePixmapType pixmap,
+                              const AttributeMap &attributes) const
+{
+    return mImplementation->validatePixmap(config, pixmap, attributes);
+}
+
 bool Display::isValidDisplay(const egl::Display *display)
 {
     const ANGLEPlatformDisplayMap *anglePlatformDisplayMap = GetANGLEPlatformDisplayMap();

src/libANGLE/Display.h

@@ -172,6 +172,9 @@ class Display final : public LabeledObject, angle::NonCopyable
                                     EGLenum target,
                                     EGLClientBuffer clientBuffer,
                                     const egl::AttributeMap &attribs) const;
+    Error valdiatePixmap(Config *config,
+                         EGLNativePixmapType pixmap,
+                         const AttributeMap &attributes) const;
 
     static bool isValidDisplay(const Display *display);
     static bool isValidNativeDisplay(EGLNativeDisplayType display);

src/libANGLE/Error.h

@@ -100,6 +100,7 @@ using EglBadDevice         = priv::ErrorStream<EGL_BAD_DEVICE_EXT>;
 using EglBadDisplay        = priv::ErrorStream<EGL_BAD_DISPLAY>;
 using EglBadMatch          = priv::ErrorStream<EGL_BAD_MATCH>;
 using EglBadNativeWindow   = priv::ErrorStream<EGL_BAD_NATIVE_WINDOW>;
+using EglBadNativePixmap   = priv::ErrorStream<EGL_BAD_NATIVE_PIXMAP>;
 using EglBadParameter      = priv::ErrorStream<EGL_BAD_PARAMETER>;
 using EglBadState          = priv::ErrorStream<EGL_BAD_STATE_KHR>;
 using EglBadStream         = priv::ErrorStream<EGL_BAD_STREAM_KHR>;

src/libANGLE/Surface.cpp

@@ -91,6 +91,11 @@ Surface::Surface(EGLint surfaceType,
         mLargestPbuffer = (attributes.get(EGL_LARGEST_PBUFFER, EGL_FALSE) == EGL_TRUE);
     }
 
+    if (mType == EGL_PIXMAP_BIT)
+    {
+        mRenderBuffer = EGL_SINGLE_BUFFER;
+    }
+
     mGLColorspace =
         static_cast<EGLenum>(attributes.get(EGL_GL_COLORSPACE, EGL_GL_COLORSPACE_LINEAR));
     mVGAlphaFormat =

src/libANGLE/renderer/DisplayImpl.cpp

@@ -52,6 +52,14 @@ egl::Error DisplayImpl::validateImageClientBuffer(const gl::Context *context,
     return egl::EglBadDisplay() << "DisplayImpl::validateImageClientBuffer unimplemented.";
 }
 
+egl::Error DisplayImpl::validatePixmap(egl::Config *config,
+                                       EGLNativePixmapType pixmap,
+                                       const egl::AttributeMap &attributes) const
+{
+    UNREACHABLE();
+    return egl::EglBadDisplay() << "DisplayImpl::valdiatePixmap unimplemented.";
+}
+
 const egl::Caps &DisplayImpl::getCaps() const
 {
     if (!mCapsInitialized)

src/libANGLE/renderer/DisplayImpl.h

@@ -85,6 +85,9 @@ class DisplayImpl : public EGLImplFactory
                                                  EGLenum target,
                                                  EGLClientBuffer clientBuffer,
                                                  const egl::AttributeMap &attribs) const;
+    virtual egl::Error validatePixmap(egl::Config *config,
+                                      EGLNativePixmapType pixmap,
+                                      const egl::AttributeMap &attributes) const;
 
     virtual std::string getVendorString() const = 0;
 

src/libANGLE/renderer/gl/glx/DisplayGLX.cpp

@@ -20,8 +20,10 @@
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/ContextGL.h"
 #include "libANGLE/renderer/gl/glx/PbufferSurfaceGLX.h"
+#include "libANGLE/renderer/gl/glx/PixmapSurfaceGLX.h"
 #include "libANGLE/renderer/gl/glx/RendererGLX.h"
 #include "libANGLE/renderer/gl/glx/WindowSurfaceGLX.h"
+#include "libANGLE/renderer/gl/glx/glx_utils.h"
 #include "libANGLE/renderer/gl/renderergl_utils.h"
 
 namespace
@@ -426,8 +428,31 @@ SurfaceImpl *DisplayGLX::createPixmapSurface(const egl::SurfaceState &state,
                                              NativePixmapType nativePixmap,
                                              const egl::AttributeMap &attribs)
 {
-    UNIMPLEMENTED();
-    return nullptr;
+    ASSERT(configIdToGLXConfig.count(state.config->configID) > 0);
+    glx::FBConfig fbConfig = configIdToGLXConfig[state.config->configID];
+    return new PixmapSurfaceGLX(state, nativePixmap, mGLX.getDisplay(), mGLX, fbConfig);
+}
+
+egl::Error DisplayGLX::validatePixmap(egl::Config *config,
+                                      EGLNativePixmapType pixmap,
+                                      const egl::AttributeMap &attributes) const
+{
+    Window rootWindow;
+    int x                    = 0;
+    int y                    = 0;
+    unsigned int width       = 0;
+    unsigned int height      = 0;
+    unsigned int borderWidth = 0;
+    unsigned int depth       = 0;
+    int status = XGetGeometry(mGLX.getDisplay(), pixmap, &rootWindow, &x, &y, &width, &height,
+                              &borderWidth, &depth);
+    if (!status)
+    {
+        return egl::EglBadNativePixmap() << "Invalid native pixmap, XGetGeometry failed: "
+                                         << x11::XErrorToString(mXDisplay, status);
+    }
+
+    return egl::NoError();
 }
 
 ContextImpl *DisplayGLX::createContext(const gl::State &state,
@@ -654,14 +679,6 @@ egl::ConfigSet DisplayGLX::generateConfigs()
         // Misc
         config.level = getGLXFBConfigAttrib(glxConfig, GLX_LEVEL);
 
-        config.bindToTextureRGB  = EGL_FALSE;
-        config.bindToTextureRGBA = EGL_FALSE;
-
-        int glxDrawable    = getGLXFBConfigAttrib(glxConfig, GLX_DRAWABLE_TYPE);
-        config.surfaceType = 0 | (glxDrawable & GLX_WINDOW_BIT ? EGL_WINDOW_BIT : 0) |
-                             (glxDrawable & GLX_PBUFFER_BIT ? EGL_PBUFFER_BIT : 0) |
-                             (glxDrawable & GLX_PIXMAP_BIT ? EGL_PIXMAP_BIT : 0);
-
         config.minSwapInterval = mMinSwapInterval;
         config.maxSwapInterval = mMaxSwapInterval;
 
@@ -678,6 +695,39 @@ egl::ConfigSet DisplayGLX::generateConfigs()
 
         config.colorComponentType = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
 
+        // GLX doesn't support binding pbuffers to textures and there is no way to differentiate in
+        // EGL that pixmaps can be bound but pbuffers cannot.  If both pixmaps and pbuffers are
+        // supported, generate extra configs with either pbuffer or pixmap support.
+        int glxDrawable     = getGLXFBConfigAttrib(glxConfig, GLX_DRAWABLE_TYPE);
+        bool pbufferSupport = (glxDrawable & EGL_PBUFFER_BIT) != 0;
+        bool pixmapSupport  = (glxDrawable & GLX_PIXMAP_BIT) != 0;
+        bool pixmapBindToTextureSupport =
+            pixmapSupport && mGLX.hasExtension("GLX_EXT_texture_from_pixmap");
+
+        if (pbufferSupport && pixmapBindToTextureSupport)
+        {
+            // Generate the pixmap-only config
+            config.surfaceType = (glxDrawable & GLX_WINDOW_BIT ? EGL_WINDOW_BIT : 0) |
+                                 (pixmapSupport ? EGL_PIXMAP_BIT : 0);
+
+            config.bindToTextureRGB = getGLXFBConfigAttrib(glxConfig, GLX_BIND_TO_TEXTURE_RGB_EXT);
+            config.bindToTextureRGBA =
+                getGLXFBConfigAttrib(glxConfig, GLX_BIND_TO_TEXTURE_RGBA_EXT);
+            config.yInverted = getGLXFBConfigAttrib(glxConfig, GLX_Y_INVERTED_EXT);
+
+            int id                  = configs.add(config);
+            configIdToGLXConfig[id] = glxConfig;
+        }
+
+        // Generate the pbuffer config. It can support pixmaps but not bind-to-texture.
+        config.surfaceType = (glxDrawable & GLX_WINDOW_BIT ? EGL_WINDOW_BIT : 0) |
+                             (pbufferSupport ? EGL_PBUFFER_BIT : 0) |
+                             (pixmapSupport ? EGL_PIXMAP_BIT : 0);
+
+        config.bindToTextureRGB  = false;
+        config.bindToTextureRGBA = false;
+        config.yInverted         = false;
+
         int id                  = configs.add(config);
         configIdToGLXConfig[id] = glxConfig;
     }
@@ -830,6 +880,8 @@ void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const
     outExtensions->syncControlCHROMIUM  = hasSyncControlOML;
     outExtensions->syncControlRateANGLE = hasSyncControlOML;
 
+    outExtensions->textureFromPixmapNOK = mGLX.hasExtension("GLX_EXT_texture_from_pixmap");
+
     DisplayGL::generateExtensions(outExtensions);
 }
 

src/libANGLE/renderer/gl/glx/DisplayGLX.h

@@ -50,6 +50,10 @@ class DisplayGLX : public DisplayGL
                                      NativePixmapType nativePixmap,
                                      const egl::AttributeMap &attribs) override;
 
+    egl::Error validatePixmap(egl::Config *config,
+                              EGLNativePixmapType pixmap,
+                              const egl::AttributeMap &attributes) const override;
+
     ContextImpl *createContext(const gl::State &state,
                                gl::ErrorSet *errorSet,
                                const egl::Config *configuration,

src/libANGLE/renderer/gl/glx/FunctionsGLX.cpp

@@ -56,12 +56,16 @@ struct FunctionsGLX::GLXFunctionTable
           createPbufferPtr(nullptr),
           destroyPbufferPtr(nullptr),
           queryDrawablePtr(nullptr),
+          createPixmapPtr(nullptr),
+          destroyPixmapPtr(nullptr),
           createContextAttribsARBPtr(nullptr),
           swapIntervalEXTPtr(nullptr),
           swapIntervalMESAPtr(nullptr),
           swapIntervalSGIPtr(nullptr),
           getSyncValuesOMLPtr(nullptr),
-          getMscRateOMLPtr(nullptr)
+          getMscRateOMLPtr(nullptr),
+          bindTexImageEXTPtr(nullptr),
+          releaseTexImageEXTPtr(nullptr)
     {}
 
     // GLX 1.0
@@ -90,6 +94,8 @@ struct FunctionsGLX::GLXFunctionTable
     PFNGLXCREATEPBUFFERPROC createPbufferPtr;
     PFNGLXDESTROYPBUFFERPROC destroyPbufferPtr;
     PFNGLXQUERYDRAWABLEPROC queryDrawablePtr;
+    PFNGLXCREATEPIXMAPPROC createPixmapPtr;
+    PFNGLXDESTROYPIXMAPPROC destroyPixmapPtr;
 
     // GLX_ARB_create_context
     PFNGLXCREATECONTEXTATTRIBSARBPROC createContextAttribsARBPtr;
@@ -106,6 +112,10 @@ struct FunctionsGLX::GLXFunctionTable
     // GLX_OML_sync_control
     PFNGLXGETSYNCVALUESOMLPROC getSyncValuesOMLPtr;
     PFNGLXGETMSCRATEOMLPROC getMscRateOMLPtr;
+
+    // GLX_EXT_texture_from_pixmap
+    PFNGLXBINDTEXIMAGEEXTPROC bindTexImageEXTPtr;
+    PFNGLXRELEASETEXIMAGEEXTPROC releaseTexImageEXTPtr;
 };
 
 FunctionsGLX::FunctionsGLX()
@@ -228,6 +238,8 @@ bool FunctionsGLX::initialize(Display *xDisplay, int screen, std::string *errorS
     GET_FNPTR_OR_ERROR(&mFnPtrs->createPbufferPtr, glXCreatePbuffer);
     GET_FNPTR_OR_ERROR(&mFnPtrs->destroyPbufferPtr, glXDestroyPbuffer);
     GET_FNPTR_OR_ERROR(&mFnPtrs->queryDrawablePtr, glXQueryDrawable);
+    GET_FNPTR_OR_ERROR(&mFnPtrs->createPixmapPtr, glXCreatePixmap);
+    GET_FNPTR_OR_ERROR(&mFnPtrs->destroyPixmapPtr, glXDestroyPixmap);
 
     // Extensions
     if (hasExtension("GLX_ARB_create_context"))
@@ -251,6 +263,11 @@ bool FunctionsGLX::initialize(Display *xDisplay, int screen, std::string *errorS
         GET_PROC_OR_ERROR(&mFnPtrs->getSyncValuesOMLPtr, glXGetSyncValuesOML);
         GET_PROC_OR_ERROR(&mFnPtrs->getMscRateOMLPtr, glXGetMscRateOML);
     }
+    if (hasExtension("GLX_EXT_texture_from_pixmap"))
+    {
+        GET_PROC_OR_ERROR(&mFnPtrs->bindTexImageEXTPtr, glXBindTexImageEXT);
+        GET_PROC_OR_ERROR(&mFnPtrs->releaseTexImageEXTPtr, glXReleaseTexImageEXT);
+    }
 
 #undef GET_FNPTR_OR_ERROR
 #undef GET_PROC_OR_ERROR
@@ -383,6 +400,18 @@ void FunctionsGLX::queryDrawable(glx::Drawable drawable, int attribute, unsigned
     mFnPtrs->queryDrawablePtr(mXDisplay, drawable, attribute, value);
 }
 
+glx::Pixmap FunctionsGLX::createPixmap(glx::FBConfig config,
+                                       Pixmap pixmap,
+                                       const int *attribList) const
+{
+    GLXFBConfig cfg = reinterpret_cast<GLXFBConfig>(config);
+    return mFnPtrs->createPixmapPtr(mXDisplay, cfg, pixmap, attribList);
+}
+void FunctionsGLX::destroyPixmap(Pixmap pixmap) const
+{
+    mFnPtrs->destroyPixmapPtr(mXDisplay, pixmap);
+}
+
 // GLX_ARB_create_context
 glx::Context FunctionsGLX::createContextAttribsARB(glx::FBConfig config,
                                                    glx::Context shareContext,
@@ -426,4 +455,12 @@ bool FunctionsGLX::getMscRateOML(glx::Drawable drawable,
     return mFnPtrs->getMscRateOMLPtr(mXDisplay, drawable, numerator, denominator);
 }
 
+void FunctionsGLX::bindTexImageEXT(glx::Drawable drawable, int buffer, const int *attribList) const
+{
+    mFnPtrs->bindTexImageEXTPtr(mXDisplay, drawable, buffer, attribList);
+}
+void FunctionsGLX::releaseTexImageEXT(glx::Drawable drawable, int buffer) const
+{
+    mFnPtrs->releaseTexImageEXTPtr(mXDisplay, drawable, buffer);
+}
 }  // namespace rx

src/libANGLE/renderer/gl/glx/FunctionsGLX.h

@@ -62,6 +62,8 @@ class FunctionsGLX
     glx::Pbuffer createPbuffer(glx::FBConfig config, const int *attribList) const;
     void destroyPbuffer(glx::Pbuffer pbuffer) const;
     void queryDrawable(glx::Drawable drawable, int attribute, unsigned int *value) const;
+    glx::Pixmap createPixmap(glx::FBConfig config, Pixmap pixmap, const int *attribList) const;
+    void destroyPixmap(Pixmap pixmap) const;
 
     // GLX_ARB_create_context
     glx::Context createContextAttribsARB(glx::FBConfig config,
@@ -82,6 +84,10 @@ class FunctionsGLX
     bool getSyncValuesOML(glx::Drawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc) const;
     bool getMscRateOML(glx::Drawable drawable, int32_t *numerator, int32_t *denominator) const;
 
+    // GLX_EXT_texture_from_pixmap
+    void bindTexImageEXT(glx::Drawable drawable, int buffer, const int *attribList) const;
+    void releaseTexImageEXT(glx::Drawable drawable, int buffer) const;
+
   private:
     // So as to isolate GLX from angle we do not include angleutils.h and cannot
     // use angle::NonCopyable so we replicated it here instead.

src/libANGLE/renderer/gl/glx/PixmapSurfaceGLX.cpp

+//
+// Copyright 2020 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.
+//
+
+// PixmapSurfaceGLX.cpp: GLX implementation of egl::Surface for Pixmaps
+
+#include "libANGLE/renderer/gl/glx/PixmapSurfaceGLX.h"
+
+#include "common/debug.h"
+#include "libANGLE/Display.h"
+#include "libANGLE/Surface.h"
+#include "libANGLE/renderer/gl/glx/DisplayGLX.h"
+#include "libANGLE/renderer/gl/glx/FunctionsGLX.h"
+#include "libANGLE/renderer/gl/glx/glx_utils.h"
+
+#include <iostream>
+
+namespace rx
+{
+
+namespace
+{
+
+int EGLTextureFormatToGLXTextureFormat(EGLint textureFormat)
+{
+    switch (textureFormat)
+    {
+        case EGL_NO_TEXTURE:
+            return GLX_TEXTURE_FORMAT_NONE_EXT;
+        case EGL_TEXTURE_RGB:
+            return GLX_TEXTURE_FORMAT_RGB_EXT;
+        case EGL_TEXTURE_RGBA:
+            return GLX_TEXTURE_FORMAT_RGBA_EXT;
+        default:
+            UNREACHABLE();
+            return GLX_TEXTURE_FORMAT_NONE_EXT;
+    }
+}
+
+int EGLTextureTargetToGLXTextureTarget(EGLint textureTarget)
+{
+    switch (textureTarget)
+    {
+        case EGL_NO_TEXTURE:
+            return 0;
+        case EGL_TEXTURE_2D:
+            return GLX_TEXTURE_2D_EXT;
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
+int EGLBufferToGLXBuffer(EGLint buffer)
+{
+    switch (buffer)
+    {
+        case EGL_BACK_BUFFER:
+            return GLX_BACK_EXT;
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
+}  // namespace
+
+PixmapSurfaceGLX::PixmapSurfaceGLX(const egl::SurfaceState &state,
+                                   Pixmap pixmap,
+                                   Display *display,
+                                   const FunctionsGLX &glx,
+                                   glx::FBConfig fbConfig)
+    : SurfaceGLX(state),
+      mWidth(0),
+      mHeight(0),
+      mGLX(glx),
+      mFBConfig(fbConfig),
+      mXPixmap(pixmap),
+      mGLXPixmap(0),
+      mDisplay(display)
+{}
+
+PixmapSurfaceGLX::~PixmapSurfaceGLX()
+{
+    if (mGLXPixmap)
+    {
+        mGLX.destroyPixmap(mGLXPixmap);
+    }
+}
+
+egl::Error PixmapSurfaceGLX::initialize(const egl::Display *display)
+{
+    DisplayGLX *displayGLX = GetImplAs<DisplayGLX>(display);
+
+    {
+        Window rootWindow;
+        int x                    = 0;
+        int y                    = 0;
+        unsigned int borderWidth = 0;
+        unsigned int depth       = 0;
+        int status = XGetGeometry(mDisplay, mXPixmap, &rootWindow, &x, &y, &mWidth, &mHeight,
+                                  &borderWidth, &depth);
+        if (!status)
+        {
+            return egl::EglBadSurface() << "XGetGeometry query failed on pixmap surface: "
+                                        << x11::XErrorToString(mDisplay, status);
+        }
+    }
+
+    std::vector<int> pixmapAttribs;
+    if (mState.attributes.contains(EGL_TEXTURE_FORMAT))
+    {
+        pixmapAttribs.push_back(GLX_TEXTURE_FORMAT_EXT);
+        pixmapAttribs.push_back(
+            EGLTextureFormatToGLXTextureFormat(mState.attributes.getAsInt(EGL_TEXTURE_FORMAT)));
+    }
+    if (mState.attributes.contains(EGL_TEXTURE_TARGET))
+    {
+        pixmapAttribs.push_back(GLX_TEXTURE_TARGET_EXT);
+        pixmapAttribs.push_back(
+            EGLTextureTargetToGLXTextureTarget(mState.attributes.getAsInt(EGL_TEXTURE_TARGET)));
+    }
+
+    pixmapAttribs.push_back(None);
+
+    mGLXPixmap = mGLX.createPixmap(mFBConfig, mXPixmap, pixmapAttribs.data());
+    if (!mGLXPixmap)
+    {
+        return egl::EglBadAlloc() << "Failed to create a native GLX pixmap.";
+    }
+
+    XFlush(mDisplay);
+    displayGLX->syncXCommands();
+
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::makeCurrent(const gl::Context *context)
+{
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::swap(const gl::Context *context)
+{
+    UNREACHABLE();
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::postSubBuffer(const gl::Context *context,
+                                           EGLint x,
+                                           EGLint y,
+                                           EGLint width,
+                                           EGLint height)
+{
+    UNREACHABLE();
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::querySurfacePointerANGLE(EGLint attribute, void **value)
+{
+    UNREACHABLE();
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::bindTexImage(const gl::Context *context,
+                                          gl::Texture *texture,
+                                          EGLint buffer)
+{
+    const int attribs[] = {None};
+    mGLX.bindTexImageEXT(mGLXPixmap, EGLBufferToGLXBuffer(buffer), attribs);
+    return egl::NoError();
+}
+
+egl::Error PixmapSurfaceGLX::releaseTexImage(const gl::Context *context, EGLint buffer)
+{
+    mGLX.releaseTexImageEXT(mGLXPixmap, EGLBufferToGLXBuffer(buffer));
+    return egl::NoError();
+}
+
+void PixmapSurfaceGLX::setSwapInterval(EGLint interval) {}
+
+EGLint PixmapSurfaceGLX::getWidth() const
+{
+    return mWidth;
+}
+
+EGLint PixmapSurfaceGLX::getHeight() const
+{
+    return mHeight;
+}
+
+EGLint PixmapSurfaceGLX::isPostSubBufferSupported() const
+{
+    UNREACHABLE();
+    return EGL_FALSE;
+}
+
+EGLint PixmapSurfaceGLX::getSwapBehavior() const
+{
+    return EGL_BUFFER_DESTROYED;
+}
+
+egl::Error PixmapSurfaceGLX::checkForResize()
+{
+    // The size of pbuffers never change
+    return egl::NoError();
+}
+
+glx::Drawable PixmapSurfaceGLX::getDrawable() const
+{
+    return mGLXPixmap;
+}
+
+}  // namespace rx

src/libANGLE/renderer/gl/glx/PixmapSurfaceGLX.h

+//
+// Copyright 2020 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.
+//
+
+// PixmapSurfaceGLX.h: GLX implementation of egl::Surface for Pixmaps
+
+#ifndef LIBANGLE_RENDERER_GL_GLX_PIXMAPSURFACEGLX_H_
+#define LIBANGLE_RENDERER_GL_GLX_PIXMAPSURFACEGLX_H_
+
+#include "libANGLE/renderer/gl/glx/SurfaceGLX.h"
+#include "libANGLE/renderer/gl/glx/platform_glx.h"
+
+namespace rx
+{
+
+class FunctionsGLX;
+
+class PixmapSurfaceGLX : public SurfaceGLX
+{
+  public:
+    PixmapSurfaceGLX(const egl::SurfaceState &state,
+                     Pixmap pixmap,
+                     Display *display,
+                     const FunctionsGLX &glx,
+                     glx::FBConfig fbConfig);
+    ~PixmapSurfaceGLX() override;
+
+    egl::Error initialize(const egl::Display *display) override;
+    egl::Error makeCurrent(const gl::Context *context) override;
+
+    egl::Error swap(const gl::Context *context) override;
+    egl::Error postSubBuffer(const gl::Context *context,
+                             EGLint x,
+                             EGLint y,
+                             EGLint width,
+                             EGLint height) override;
+    egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
+    void setSwapInterval(EGLint interval) override;
+
+    EGLint getWidth() const override;
+    EGLint getHeight() const override;
+
+    EGLint isPostSubBufferSupported() const override;
+    EGLint getSwapBehavior() const override;
+
+    egl::Error checkForResize() override;
+    glx::Drawable getDrawable() const override;
+
+  private:
+    unsigned mWidth;
+    unsigned mHeight;
+
+    const FunctionsGLX &mGLX;
+    glx::FBConfig mFBConfig;
+    Pixmap mXPixmap;
+    glx::Pixmap mGLXPixmap;
+    Display *mDisplay;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_GL_GLX_PIXMAPSURFACEGLX_H_

src/libANGLE/renderer/gl/glx/glx_utils.cpp

+//
+// Copyright 2020 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.
+//
+
+// glx_utils.cpp: Utility routines specific to the G:X->EGL implementation.
+
+#include "libANGLE/renderer/gl/glx/glx_utils.h"
+
+#include "common/angleutils.h"
+
+namespace rx
+{
+
+namespace x11
+{
+
+std::string XErrorToString(Display *display, int status)
+{
+    // Write nulls to the buffer so that if XGetErrorText fails, converting to an std::string will
+    // be an empty string.
+    char buffer[256] = {0};
+    XGetErrorText(display, status, buffer, ArraySize(buffer));
+    return std::string(buffer);
+}
+
+}  // namespace x11
+
+}  // namespace rx

src/libANGLE/renderer/gl/glx/glx_utils.h

+//
+// Copyright 2020 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.
+//
+
+// glx_utils.h: Utility routines specific to the G:X->EGL implementation.
+
+#ifndef LIBANGLE_RENDERER_GL_GLX_GLXUTILS_H_
+#define LIBANGLE_RENDERER_GL_GLX_GLXUTILS_H_
+
+#include <string>
+
+#include "common/platform.h"
+#include "libANGLE/renderer/gl/glx/FunctionsGLX.h"
+
+namespace rx
+{
+
+namespace x11
+{
+
+std::string XErrorToString(Display *display, int status);
+
+}  // namespace x11
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_GL_GLX_GLXUTILS_H_

src/libANGLE/validationEGL.cpp

@@ -232,6 +232,13 @@ Error ValidateConfigAttribute(const Display *display, EGLAttrib attribute)
             }
             break;
 
+        case EGL_Y_INVERTED_NOK:
+            if (!display->getExtensions().textureFromPixmapNOK)
+            {
+                return EglBadAttribute() << "EGL_NOK_texture_from_pixmap is not enabled.";
+            }
+            break;
+
         default:
             return EglBadAttribute() << "Unknown attribute.";
     }
@@ -1953,6 +1960,85 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display,
     return NoError();
 }
 
+Error ValidateCreatePixmapSurface(Display *display,
+                                  Config *config,
+                                  EGLNativePixmapType pixmap,
+                                  const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateConfig(display, config));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+
+    for (AttributeMap::const_iterator attributeIter = attributes.begin();
+         attributeIter != attributes.end(); attributeIter++)
+    {
+        EGLAttrib attribute = attributeIter->first;
+        EGLAttrib value     = attributeIter->second;
+
+        switch (attribute)
+        {
+            case EGL_GL_COLORSPACE:
+                ANGLE_TRY(ValidateColorspaceAttribute(displayExtensions, value));
+                break;
+
+            case EGL_VG_COLORSPACE:
+                break;
+            case EGL_VG_ALPHA_FORMAT:
+                break;
+
+            case EGL_TEXTURE_FORMAT:
+                if (!displayExtensions.textureFromPixmapNOK)
+                {
+                    return EglBadAttribute() << "EGL_NOK_texture_from_pixmap is not enabled.";
+                }
+                switch (value)
+                {
+                    case EGL_NO_TEXTURE:
+                    case EGL_TEXTURE_RGB:
+                    case EGL_TEXTURE_RGBA:
+                        break;
+                    default:
+                        return EglBadAttribute();
+                }
+                break;
+
+            case EGL_TEXTURE_TARGET:
+                if (!displayExtensions.textureFromPixmapNOK)
+                {
+                    return EglBadAttribute() << "EGL_NOK_texture_from_pixmap is not enabled.";
+                }
+                switch (value)
+                {
+                    case EGL_NO_TEXTURE:
+                    case EGL_TEXTURE_2D:
+                        break;
+                    default:
+                        return EglBadAttribute();
+                }
+                break;
+
+            case EGL_MIPMAP_TEXTURE:
+                if (!displayExtensions.textureFromPixmapNOK)
+                {
+                    return EglBadAttribute() << "EGL_NOK_texture_from_pixmap is not enabled.";
+                }
+                break;
+
+            default:
+                return EglBadAttribute() << "Unknown attribute";
+        }
+    }
+
+    if (!(config->surfaceType & EGL_PIXMAP_BIT))
+    {
+        return EglBadMatch() << "Congfig does not suport pixmaps.";
+    }
+
+    ANGLE_TRY(display->valdiatePixmap(config, pixmap, attributes));
+
+    return NoError();
+}
+
 Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context)
 {
     if (context == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))

src/libANGLE/validationEGL.h

@@ -83,6 +83,11 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display,
                                             Config *config,
                                             const AttributeMap &attributes);
 
+Error ValidateCreatePixmapSurface(Display *display,
+                                  Config *config,
+                                  EGLNativePixmapType pixmap,
+                                  const AttributeMap &attributes);
+
 Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context);
 
 Error ValidateCreateImage(const Display *display,

src/libGLESv2.gni

@@ -807,12 +807,16 @@ libangle_gl_glx_sources = [
   "src/libANGLE/renderer/gl/glx/FunctionsGLX.h",
   "src/libANGLE/renderer/gl/glx/PbufferSurfaceGLX.cpp",
   "src/libANGLE/renderer/gl/glx/PbufferSurfaceGLX.h",
+  "src/libANGLE/renderer/gl/glx/PixmapSurfaceGLX.cpp",
+  "src/libANGLE/renderer/gl/glx/PixmapSurfaceGLX.h",
   "src/libANGLE/renderer/gl/glx/RendererGLX.cpp",
   "src/libANGLE/renderer/gl/glx/RendererGLX.h",
   "src/libANGLE/renderer/gl/glx/SurfaceGLX.h",
   "src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.cpp",
   "src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.h",
   "src/libANGLE/renderer/gl/glx/functionsglx_typedefs.h",
+  "src/libANGLE/renderer/gl/glx/glx_utils.cpp",
+  "src/libANGLE/renderer/gl/glx/glx_utils.h",
   "src/libANGLE/renderer/gl/glx/platform_glx.h",
 ]
 

src/libGLESv2/entry_points_egl.cpp

@@ -305,14 +305,19 @@ EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
 
     egl::Display *display   = static_cast<egl::Display *>(dpy);
     Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateConfig(display, configuration), "eglCreatePixmapSurface",
-                         GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_TRY_RETURN(thread,
+                         ValidateCreatePixmapSurface(display, configuration, pixmap, attributes),
+                         "eglCreatePixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
 
-    UNIMPLEMENTED();  // FIXME
+    egl::Surface *surface = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread,
+                         display->createPixmapSurface(configuration, pixmap, attributes, &surface),
+                         "eglCreatePixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
 
     thread->setSuccess();
-    return EGL_NO_SURFACE;
+    return static_cast<EGLSurface>(surface);
 }
 
 EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
@@ -1060,12 +1065,24 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
                "const EGLint* attrib_list = 0x%016" PRIxPTR,
                (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list);
     Thread *thread = egl::GetCurrentThread();
+
     egl::Display *display = static_cast<egl::Display *>(dpy);
+    Config *configuration = static_cast<Config *>(config);
+    // Use reinterpret_cast since native_window could be a pointer or an actual value.
+    EGLNativePixmapType pixmap = reinterpret_cast<EGLNativePixmapType>(native_pixmap);
+    AttributeMap attributes    = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    UNIMPLEMENTED();
-    thread->setError(EglBadDisplay() << "eglCreatePlatformPixmapSurface unimplemented.", GetDebug(),
-                     "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display));
-    return EGL_NO_SURFACE;
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateCreatePixmapSurface(display, configuration, pixmap, attributes),
+        "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    egl::Surface *surface = nullptr;
+    ANGLE_EGL_TRY_RETURN(
+        thread, display->createPixmapSurface(configuration, pixmap, attributes, &surface),
+        "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    thread->setSuccess();
+    return static_cast<EGLSurface>(surface);
 }
 
 EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)

src/tests/angle_end2end_tests.gni

@@ -93,6 +93,7 @@ angle_end2end_tests_sources = [
   "gl_tests/PackUnpackTest.cpp",
   "gl_tests/ParallelShaderCompileTest.cpp",
   "gl_tests/PbufferTest.cpp",
+  "gl_tests/PixmapTest.cpp",
   "gl_tests/PointSpritesTest.cpp",
   "gl_tests/ProgramBinaryTest.cpp",
   "gl_tests/ProgramInterfaceTest.cpp",

src/tests/deqp_support/deqp_egl_test_expectations.txt

@@ -106,28 +106,8 @@
 2716 WIN VULKAN : dEQP-EGL.functional.preserve_swap.no_preserve.* = FAIL
 
 // Linux failures
-2546 LINUX : dEQP-EGL.functional.color_clears.multi_context.gles1.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.multi_context.gles1_gles2.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.multi_context.gles1_gles2_gles3.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.multi_context.gles2.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.multi_context.gles3.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.single_context.gles1.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.single_context.gles2.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.color_clears.single_context.gles3.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.create_surface.pixmap.rgba8888_depth_stencil = SKIP
-2546 LINUX : dEQP-EGL.functional.create_surface.pixmap.rgba8888_no_depth_no_stencil = SKIP
 2546 LINUX : dEQP-EGL.functional.negative_api.copy_buffers = SKIP
-2546 LINUX : dEQP-EGL.functional.query_context.get_current_context.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.query_context.get_current_display.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.query_context.get_current_surface.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.query_context.query_context.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.query_surface.set_attribute.pixmap.rgba8888_depth_stencil = SKIP
-2546 LINUX : dEQP-EGL.functional.query_surface.set_attribute.pixmap.rgba8888_no_depth_no_stencil = SKIP
-2546 LINUX : dEQP-EGL.functional.query_surface.simple.pixmap.rgba8888_depth_stencil = SKIP
-2546 LINUX : dEQP-EGL.functional.query_surface.simple.pixmap.rgba8888_no_depth_no_stencil = SKIP
 2546 LINUX : dEQP-EGL.functional.render.multi_context.* = SKIP
-2546 LINUX : dEQP-EGL.functional.render.single_context.gles2.rgba8888_pixmap = SKIP
-2546 LINUX : dEQP-EGL.functional.render.single_context.gles3.rgba8888_pixmap = SKIP
 2546 LINUX : dEQP-EGL.functional.thread_cleanup.* = SKIP
 2546 LINUX : dEQP-EGL.functional.native_color_mapping.native_window.* = FAIL
 2546 LINUX : dEQP-EGL.functional.native_coord_mapping.native_window.* = FAIL

src/tests/deqp_support/tcuANGLENativeDisplayFactory.cpp

@@ -50,6 +50,16 @@ namespace tcu
 namespace
 {
 
+template <typename destType, typename sourceType>
+destType bitCast(sourceType source)
+{
+    constexpr size_t copySize =
+        sizeof(destType) < sizeof(sourceType) ? sizeof(destType) : sizeof(sourceType);
+    destType output(0);
+    memcpy(&output, &source, copySize);
+    return output;
+}
+
 enum
 {
     DEFAULT_SURFACE_WIDTH  = 400,
@@ -74,16 +84,14 @@ constexpr eglu::NativeWindow::Capability kWindowCapabilities =
 class ANGLENativeDisplay : public eglu::NativeDisplay
 {
   public:
-    explicit ANGLENativeDisplay(std::vector<eglw::EGLAttrib> attribs);
+    explicit ANGLENativeDisplay(EGLNativeDisplayType display, std::vector<eglw::EGLAttrib> attribs);
     ~ANGLENativeDisplay() override = default;
 
     void *getPlatformNative() override
     {
         // On OSX 64bits mDeviceContext is a 32 bit integer, so we can't simply
         // use reinterpret_cast<void*>.
-        void *result = nullptr;
-        memcpy(&result, &mDeviceContext, sizeof(mDeviceContext));
-        return result;
+        return bitCast<void *>(mDeviceContext);
     }
     const eglw::EGLAttrib *getPlatformAttributes() const override
     {
@@ -169,9 +177,9 @@ class NativeWindow : public eglu::NativeWindow
 
 // ANGLE NativeDisplay
 
-ANGLENativeDisplay::ANGLENativeDisplay(std::vector<EGLAttrib> attribs)
+ANGLENativeDisplay::ANGLENativeDisplay(EGLNativeDisplayType display, std::vector<EGLAttrib> attribs)
     : eglu::NativeDisplay(kDisplayCapabilities, EGL_PLATFORM_ANGLE_ANGLE, "EGL_EXT_platform_base"),
-      mDeviceContext(EGL_DEFAULT_DISPLAY),
+      mDeviceContext(display),
       mLibrary(ANGLE_EGL_LIBRARY_FULL_NAME),
       mPlatformAttributes(std::move(attribs))
 {}
@@ -220,24 +228,15 @@ eglu::NativePixmap *NativePixmapFactory::createPixmap(eglu::NativeDisplay *nativ
                                                       int height) const
 {
     const eglw::Library &egl = nativeDisplay->getLibrary();
-    int redBits              = 0;
-    int greenBits            = 0;
-    int blueBits             = 0;
-    int alphaBits            = 0;
-    int bitSum               = 0;
+    int nativeVisual         = 0;
 
     DE_ASSERT(display != EGL_NO_DISPLAY);
 
-    egl.getConfigAttrib(display, config, EGL_RED_SIZE, &redBits);
-    egl.getConfigAttrib(display, config, EGL_GREEN_SIZE, &greenBits);
-    egl.getConfigAttrib(display, config, EGL_BLUE_SIZE, &blueBits);
-    egl.getConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaBits);
+    egl.getConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisual);
     EGLU_CHECK_MSG(egl, "eglGetConfigAttrib()");
 
-    bitSum = redBits + greenBits + blueBits + alphaBits;
-
     return new NativePixmap(dynamic_cast<ANGLENativeDisplay *>(nativeDisplay)->getDeviceContext(),
-                            width, height, bitSum);
+                            width, height, nativeVisual);
 }
 
 eglu::NativePixmap *NativePixmapFactory::createPixmap(eglu::NativeDisplay *nativeDisplay,
@@ -364,8 +363,15 @@ ANGLENativeDisplayFactory::ANGLENativeDisplayFactory(
                                  kDisplayCapabilities,
                                  EGL_PLATFORM_ANGLE_ANGLE,
                                  "EGL_EXT_platform_base"),
+      mNativeDisplay(bitCast<eglw::EGLNativeDisplayType>(EGL_DEFAULT_DISPLAY)),
       mPlatformAttributes(std::move(platformAttributes))
 {
+#if (DE_OS == DE_OS_UNIX)
+    // Make sure to only open the X display once so that it can be used by the EGL display as well
+    // as pixmaps
+    mNativeDisplay = bitCast<eglw::EGLNativeDisplayType>(XOpenDisplay(nullptr));
+#endif  // (DE_OS == DE_OS_UNIX)
+
     m_nativeWindowRegistry.registerFactory(new NativeWindowFactory(eventState));
     m_nativePixmapRegistry.registerFactory(new NativePixmapFactory());
 }
@@ -376,7 +382,8 @@ eglu::NativeDisplay *ANGLENativeDisplayFactory::createDisplay(
     const eglw::EGLAttrib *attribList) const
 {
     DE_UNREF(attribList);
-    return new ANGLENativeDisplay(mPlatformAttributes);
+    return new ANGLENativeDisplay(bitCast<EGLNativeDisplayType>(mNativeDisplay),
+                                  mPlatformAttributes);
 }
 
 }  // namespace tcu

src/tests/deqp_support/tcuANGLENativeDisplayFactory.h

@@ -51,6 +51,7 @@ class ANGLENativeDisplayFactory : public eglu::NativeDisplayFactory
     eglu::NativeDisplay *createDisplay(const eglw::EGLAttrib *attribList) const override;
 
   private:
+    eglw::EGLNativeDisplayType mNativeDisplay;
     std::vector<eglw::EGLAttrib> mPlatformAttributes;
 };
 

src/tests/egl_tests/EGLBackwardsCompatibleContextTest.cpp

@@ -57,14 +57,23 @@ class EGLBackwardsCompatibleContextTest : public ANGLETest
                 break;
             }
         }
+        if (!mConfig)
+        {
+            mConfig = configs[0];
+        }
         ASSERT_NE(nullptr, mConfig);
 
+        EGLint surfaceType = EGL_NONE;
+        eglGetConfigAttrib(mDisplay, mConfig, EGL_SURFACE_TYPE, &surfaceType);
+        if (surfaceType & EGL_PBUFFER_BIT)
+        {
             const EGLint pbufferAttribs[] = {
                 EGL_WIDTH, 500, EGL_HEIGHT, 500, EGL_NONE,
             };
             mPbuffer = eglCreatePbufferSurface(mDisplay, mConfig, pbufferAttribs);
             EXPECT_TRUE(mPbuffer != EGL_NO_SURFACE);
         }
+    }
 
     void testTearDown() override
     {
@@ -95,6 +104,7 @@ TEST_P(EGLBackwardsCompatibleContextTest, BackwardsCompatibleDisbled)
 {
     ANGLE_SKIP_TEST_IF(
         !IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_backwards_compatible"));
+    ANGLE_SKIP_TEST_IF(!mPbuffer);
 
     std::pair<EGLint, EGLint> testVersions[] = {
         {1, 0}, {1, 1}, {2, 0}, {3, 0}, {3, 1}, {3, 2},
@@ -133,6 +143,7 @@ TEST_P(EGLBackwardsCompatibleContextTest, BackwardsCompatibleEnabledES3)
 {
     ANGLE_SKIP_TEST_IF(
         !IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_backwards_compatible"));
+    ANGLE_SKIP_TEST_IF(!mPbuffer);
 
     EGLint es3ContextAttribs[] = {
         EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 0, EGL_NONE, EGL_NONE};
@@ -162,6 +173,7 @@ TEST_P(EGLBackwardsCompatibleContextTest, BackwardsCompatibleEnabledES1)
 {
     ANGLE_SKIP_TEST_IF(
         !IsEGLDisplayExtensionEnabled(mDisplay, "EGL_ANGLE_create_context_backwards_compatible"));
+    ANGLE_SKIP_TEST_IF(!mPbuffer);
 
     EGLint es11ContextAttribs[] = {
         EGL_CONTEXT_MAJOR_VERSION, 1, EGL_CONTEXT_MINOR_VERSION, 1, EGL_NONE, EGL_NONE};

src/tests/egl_tests/EGLQueryContextTest.cpp

@@ -32,8 +32,6 @@ class EGLQueryContextTest : public ANGLETest
                              8,
                              EGL_RENDERABLE_TYPE,
                              clientVersion == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT,
-                             EGL_SURFACE_TYPE,
-                             EGL_PBUFFER_BIT,
                              EGL_NONE};
         EXPECT_TRUE(eglChooseConfig(mDisplay, cfgattrs, &mConfig, 1, &ncfg) != EGL_FALSE);
         EXPECT_TRUE(ncfg == 1);
@@ -42,10 +40,15 @@ class EGLQueryContextTest : public ANGLETest
         mContext          = eglCreateContext(mDisplay, mConfig, nullptr, ctxattrs);
         EXPECT_TRUE(mContext != EGL_NO_CONTEXT);
 
+        EGLint surfaceType = EGL_NONE;
+        eglGetConfigAttrib(mDisplay, mConfig, EGL_SURFACE_TYPE, &surfaceType);
+        if (surfaceType & EGL_PBUFFER_BIT)
+        {
             EGLint surfattrs[] = {EGL_WIDTH, 16, EGL_HEIGHT, 16, EGL_NONE};
             mSurface           = eglCreatePbufferSurface(mDisplay, mConfig, surfattrs);
             EXPECT_TRUE(mSurface != EGL_NO_SURFACE);
         }
+    }
 
     void testTearDown() override
     {
@@ -53,16 +56,19 @@ class EGLQueryContextTest : public ANGLETest
         {
             eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
             eglDestroyContext(mDisplay, mContext);
+            if (mSurface)
+            {
                 eglDestroySurface(mDisplay, mSurface);
+            }
             eglTerminate(mDisplay);
         }
         ASSERT_EGL_SUCCESS() << "Error during test TearDown";
     }
 
-    EGLDisplay mDisplay;
-    EGLConfig mConfig;
-    EGLContext mContext;
-    EGLSurface mSurface;
+    EGLDisplay mDisplay = EGL_NO_DISPLAY;
+    EGLConfig mConfig   = EGL_NO_CONFIG_KHR;
+    EGLContext mContext = EGL_NO_CONTEXT;
+    EGLSurface mSurface = EGL_NO_SURFACE;
 };
 
 TEST_P(EGLQueryContextTest, GetConfigID)
@@ -98,6 +104,8 @@ TEST_P(EGLQueryContextTest, GetRenderBufferNoSurface)
 
 TEST_P(EGLQueryContextTest, GetRenderBufferBoundSurface)
 {
+    ANGLE_SKIP_TEST_IF(!mSurface);
+
     EGLint renderBuffer, contextRenderBuffer;
     EXPECT_TRUE(eglQuerySurface(mDisplay, mSurface, EGL_RENDER_BUFFER, &renderBuffer) != EGL_FALSE);
     EXPECT_TRUE(eglMakeCurrent(mDisplay, mSurface, mSurface, mContext) != EGL_FALSE);

src/tests/egl_tests/EGLSurfaceTest.cpp

@@ -133,14 +133,22 @@ class EGLSurfaceTest : public ANGLETest
     {
         mConfig = config;
 
+        EGLint surfaceType = EGL_NONE;
+        eglGetConfigAttrib(mDisplay, mConfig, EGL_SURFACE_TYPE, &surfaceType);
+
         std::vector<EGLint> windowAttributes;
         windowAttributes.push_back(EGL_NONE);
 
+        if (surfaceType & EGL_WINDOW_BIT)
+        {
             // Create first window surface
             mWindowSurface = eglCreateWindowSurface(mDisplay, mConfig, mOSWindow->getNativeWindow(),
                                                     windowAttributes.data());
             ASSERT_EGL_SUCCESS();
+        }
 
+        if (surfaceType & EGL_PBUFFER_BIT)
+        {
             // Give pbuffer non-zero dimensions.
             std::vector<EGLint> pbufferAttributes;
             pbufferAttributes.push_back(EGL_WIDTH);
@@ -151,6 +159,8 @@ class EGLSurfaceTest : public ANGLETest
 
             mPbufferSurface = eglCreatePbufferSurface(mDisplay, mConfig, pbufferAttributes.data());
             ASSERT_EGL_SUCCESS();
+        }
+
         initializeContext();
     }
 
@@ -378,6 +388,7 @@ TEST_P(EGLSurfaceTest, MessageLoopBugContext)
     initializeDisplay();
     initializeSurfaceWithDefaultConfig();
 
+    ANGLE_SKIP_TEST_IF(!mPbufferSurface);
     runMessageLoopTest(mPbufferSurface, mSecondContext);
 }
 

src/tests/egl_tests/EGLSurfacelessContextTest.cpp

@@ -48,9 +48,16 @@ class EGLSurfacelessContextTest : public ANGLETest
             if (surfaceType & EGL_PBUFFER_BIT)
             {
                 mConfig           = config;
+                mSupportsPbuffers = true;
                 break;
             }
         }
+
+        if (!mConfig)
+        {
+            mConfig = configs[0];
+        }
+
         ASSERT_NE(nullptr, mConfig);
     }
 
@@ -83,6 +90,11 @@ class EGLSurfacelessContextTest : public ANGLETest
 
     EGLSurface createPbuffer(int width, int height)
     {
+        if (!mSupportsPbuffers)
+        {
+            return EGL_NO_SURFACE;
+        }
+
         const EGLint pbufferAttribs[] = {
             EGL_WIDTH, 500, EGL_HEIGHT, 500, EGL_NONE,
         };
@@ -118,6 +130,7 @@ class EGLSurfacelessContextTest : public ANGLETest
 
     EGLContext mContext    = EGL_NO_CONTEXT;
     EGLSurface mPbuffer    = EGL_NO_SURFACE;
+    bool mSupportsPbuffers = false;
     EGLConfig mConfig      = 0;
     EGLDisplay mDisplay    = EGL_NO_DISPLAY;
 };
@@ -214,10 +227,8 @@ TEST_P(EGLSurfacelessContextTest, ClearReadPixelsInFBO)
 // Test clear+readpixels in an FBO in surfaceless and in the default FBO in a pbuffer
 TEST_P(EGLSurfacelessContextTest, Switcheroo)
 {
-    if (!checkExtension())
-    {
-        return;
-    }
+    ANGLE_SKIP_TEST_IF(!checkExtension());
+    ANGLE_SKIP_TEST_IF(!mSupportsPbuffers);
 
     EGLContext context = createContext();
     EGLSurface pbuffer = createPbuffer(500, 500);

src/tests/egl_tests/EGLX11VisualTest.cpp

@@ -107,17 +107,17 @@ TEST_P(EGLX11VisualHintTest, ValidVisualIDAndClear)
 
     ASSERT_TRUE(EGL_TRUE == eglInitialize(display, nullptr, nullptr));
 
-    // While this is not required by the extension, test that our implementation returns only one
-    // config, with the same native visual Id that we provided.
     int nConfigs = 0;
     ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, nullptr, 0, &nConfigs));
-    ASSERT_EQ(1, nConfigs);
+    ASSERT_GE(nConfigs, 1);
 
     int nReturnedConfigs = 0;
-    EGLConfig config;
-    ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, &config, 1, &nReturnedConfigs));
+    std::vector<EGLConfig> configs(nConfigs);
+    ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, configs.data(), nConfigs, &nReturnedConfigs));
     ASSERT_EQ(nConfigs, nReturnedConfigs);
 
+    for (EGLConfig config : configs)
+    {
         EGLint eglNativeId;
         ASSERT_TRUE(EGL_TRUE ==
                     eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &eglNativeId));
@@ -145,6 +145,7 @@ TEST_P(EGLX11VisualHintTest, ValidVisualIDAndClear)
 
         eglDestroyContext(display, context);
         ASSERT_EGL_SUCCESS();
+    }
 
     OSWindow::Delete(&osWindow);
 

src/tests/gl_tests/PbufferTest.cpp

@@ -95,15 +95,18 @@ class PbufferTest : public ANGLETest
     {
         glDeleteProgram(mTextureProgram);
 
+        if (mPbuffer)
+        {
             EGLWindow *window = getEGLWindow();
             eglDestroySurface(window->getDisplay(), mPbuffer);
         }
+    }
 
     GLuint mTextureProgram;
     GLint mTextureUniformLocation;
 
     const size_t mPbufferSize = 32;
-    EGLSurface mPbuffer;
+    EGLSurface mPbuffer       = EGL_NO_SURFACE;
     bool mSupportsPbuffers;
     bool mSupportsBindTexImage;
 };
@@ -122,7 +125,7 @@ TEST_P(PbufferTest, Clearing)
     glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
     ASSERT_GL_NO_ERROR();
-    EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, 0, 0, 255, 255);
+    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, getWindowHeight() / 2, GLColor::blue);
 
     // Apply the Pbuffer and clear it to purple and verify
     eglMakeCurrent(window->getDisplay(), mPbuffer, mPbuffer, window->getContext());
@@ -159,8 +162,8 @@ TEST_P(PbufferTest, BindTexImage)
     glClear(GL_COLOR_BUFFER_BIT);
     ASSERT_GL_NO_ERROR();
 
-    EXPECT_PIXEL_EQ(static_cast<GLint>(mPbufferSize) / 2, static_cast<GLint>(mPbufferSize) / 2, 255,
-                    0, 255, 255);
+    EXPECT_PIXEL_COLOR_EQ(static_cast<GLint>(mPbufferSize) / 2,
+                          static_cast<GLint>(mPbufferSize) / 2, GLColor::magenta);
 
     // Apply the window surface
     window->makeCurrent();

src/tests/gl_tests/PixmapTest.cpp

+//
+// Copyright 2020 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 "test_utils/ANGLETest.h"
+#include "test_utils/gl_raii.h"
+#include "util/EGLWindow.h"
+#include "util/OSPixmap.h"
+#include "util/OSWindow.h"
+
+#include <iostream>
+
+using namespace angle;
+
+class PixmapTest : public ANGLETest
+{
+  protected:
+    PixmapTest()
+    {
+        setWindowWidth(512);
+        setWindowHeight(512);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+    }
+
+    void testSetUp() override
+    {
+        mTextureProgram =
+            CompileProgram(essl1_shaders::vs::Texture2D(), essl1_shaders::fs::Texture2D());
+        if (mTextureProgram == 0)
+        {
+            FAIL() << "shader compilation failed.";
+        }
+
+        mTextureUniformLocation = glGetUniformLocation(mTextureProgram, "u_tex2D");
+        ASSERT_NE(-1, mTextureUniformLocation);
+
+        EGLWindow *window = getEGLWindow();
+
+        EGLint surfaceType = 0;
+        eglGetConfigAttrib(window->getDisplay(), window->getConfig(), EGL_SURFACE_TYPE,
+                           &surfaceType);
+        mSupportsPixmaps = (surfaceType & EGL_PIXMAP_BIT) != 0;
+
+        EGLint bindToTextureRGBA = 0;
+        eglGetConfigAttrib(window->getDisplay(), window->getConfig(), EGL_BIND_TO_TEXTURE_RGBA,
+                           &bindToTextureRGBA);
+        mSupportsBindTexImage =
+            IsEGLDisplayExtensionEnabled(window->getDisplay(), "EGL_NOK_texture_from_pixmap") &&
+            (bindToTextureRGBA == EGL_TRUE);
+
+        if (mSupportsPixmaps)
+        {
+            mOSPixmap.reset(CreateOSPixmap());
+
+            OSWindow *osWindow = getOSWindow();
+
+            EGLint nativeVisual = 0;
+            ASSERT_TRUE(eglGetConfigAttrib(window->getDisplay(), window->getConfig(),
+                                           EGL_NATIVE_VISUAL_ID, &nativeVisual));
+            ASSERT_TRUE(mOSPixmap->initialize(osWindow->getNativeDisplay(), mPixmapSize,
+                                              mPixmapSize, nativeVisual));
+
+            std::vector<EGLint> attribs;
+            if (mSupportsBindTexImage)
+            {
+                attribs.push_back(EGL_TEXTURE_FORMAT);
+                attribs.push_back(EGL_TEXTURE_RGBA);
+
+                attribs.push_back(EGL_TEXTURE_TARGET);
+                attribs.push_back(EGL_TEXTURE_2D);
+            }
+
+            attribs.push_back(EGL_NONE);
+
+            mPixmap = eglCreatePixmapSurface(window->getDisplay(), window->getConfig(),
+                                             mOSPixmap->getNativePixmap(), attribs.data());
+            ASSERT_NE(mPixmap, EGL_NO_SURFACE);
+            ASSERT_EGL_SUCCESS();
+        }
+
+        ASSERT_GL_NO_ERROR();
+    }
+
+    void testTearDown() override
+    {
+        glDeleteProgram(mTextureProgram);
+
+        if (mPixmap)
+        {
+            EGLWindow *window = getEGLWindow();
+            eglDestroySurface(window->getDisplay(), mPixmap);
+        }
+
+        mOSPixmap = nullptr;
+    }
+
+    GLuint mTextureProgram;
+    GLint mTextureUniformLocation;
+
+    std::unique_ptr<OSPixmap> mOSPixmap;
+    EGLSurface mPixmap = EGL_NO_SURFACE;
+
+    const size_t mPixmapSize = 32;
+    bool mSupportsPixmaps;
+    bool mSupportsBindTexImage;
+};
+
+// Test clearing a Pixmap and checking the color is correct
+TEST_P(PixmapTest, Clearing)
+{
+    ANGLE_SKIP_TEST_IF(!mSupportsPixmaps);
+
+    EGLWindow *window = getEGLWindow();
+
+    // Clear the window surface to blue and verify
+    window->makeCurrent();
+    ASSERT_EGL_SUCCESS();
+
+    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ASSERT_GL_NO_ERROR();
+    EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, 0, 0, 255, 255);
+
+    // Apply the Pixmap and clear it to purple and verify
+    eglMakeCurrent(window->getDisplay(), mPixmap, mPixmap, window->getContext());
+    ASSERT_EGL_SUCCESS();
+
+    glViewport(0, 0, static_cast<GLsizei>(mPixmapSize), static_cast<GLsizei>(mPixmapSize));
+    glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ASSERT_GL_NO_ERROR();
+    EXPECT_PIXEL_EQ(static_cast<GLint>(mPixmapSize) / 2, static_cast<GLint>(mPixmapSize) / 2, 255,
+                    0, 255, 255);
+
+    // Rebind the window surface and verify that it is still blue
+    window->makeCurrent();
+    ASSERT_EGL_SUCCESS();
+    EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, 0, 0, 255, 255);
+}
+
+// Bind the Pixmap to a texture and verify it renders correctly
+TEST_P(PixmapTest, BindTexImage)
+{
+    // Test skipped because pixmaps are not supported or pixmaps do not support binding to RGBA
+    // textures.
+    ANGLE_SKIP_TEST_IF(!mSupportsPixmaps || !mSupportsBindTexImage);
+
+    // This test fails flakily on Linux intel when run with many other tests.
+    ANGLE_SKIP_TEST_IF(IsLinux() && IsIntel());
+
+    EGLWindow *window = getEGLWindow();
+
+    // Apply the Pixmap and clear it to purple
+    eglMakeCurrent(window->getDisplay(), mPixmap, mPixmap, window->getContext());
+    ASSERT_EGL_SUCCESS();
+
+    glViewport(0, 0, static_cast<GLsizei>(mPixmapSize), static_cast<GLsizei>(mPixmapSize));
+    glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ASSERT_GL_NO_ERROR();
+
+    EXPECT_PIXEL_EQ(static_cast<GLint>(mPixmapSize) / 2, static_cast<GLint>(mPixmapSize) / 2, 255,
+                    0, 255, 255);
+
+    // Apply the window surface
+    window->makeCurrent();
+
+    // Create a texture and bind the pixmap to it
+    GLuint texture = 0;
+    glGenTextures(1, &texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    EXPECT_GL_NO_ERROR();
+
+    eglBindTexImage(window->getDisplay(), mPixmap, EGL_BACK_BUFFER);
+    glViewport(0, 0, getWindowWidth(), getWindowHeight());
+    ASSERT_EGL_SUCCESS();
+
+    // Draw a quad and verify that it is purple
+    glUseProgram(mTextureProgram);
+    glUniform1i(mTextureUniformLocation, 0);
+
+    drawQuad(mTextureProgram, essl31_shaders::PositionAttrib(), 0.5f);
+    EXPECT_GL_NO_ERROR();
+
+    // Unbind the texture
+    eglReleaseTexImage(window->getDisplay(), mPixmap, EGL_BACK_BUFFER);
+    ASSERT_EGL_SUCCESS();
+
+    // Verify that purple was drawn
+    EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, 255, 0, 255, 255);
+
+    glDeleteTextures(1, &texture);
+}
+
+// Bind a Pixmap, redefine the texture, and verify it renders correctly
+TEST_P(PixmapTest, BindTexImageAndRedefineTexture)
+{
+    // Test skipped because pixmaps are not supported or Pixmaps do not support binding to RGBA
+    // textures.
+    ANGLE_SKIP_TEST_IF(!mSupportsPixmaps || !mSupportsBindTexImage);
+
+    EGLWindow *window = getEGLWindow();
+
+    // Apply the Pixmap and clear it to purple
+    eglMakeCurrent(window->getDisplay(), mPixmap, mPixmap, window->getContext());
+    ASSERT_EGL_SUCCESS();
+
+    glViewport(0, 0, static_cast<GLsizei>(mPixmapSize), static_cast<GLsizei>(mPixmapSize));
+    glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ASSERT_GL_NO_ERROR();
+
+    EXPECT_PIXEL_EQ(static_cast<GLint>(mPixmapSize) / 2, static_cast<GLint>(mPixmapSize) / 2, 255,
+                    0, 255, 255);
+
+    // Apply the window surface
+    window->makeCurrent();
+
+    // Create a texture and bind the Pixmap to it
+    GLuint texture = 0;
+    glGenTextures(1, &texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    EXPECT_GL_NO_ERROR();
+
+    eglBindTexImage(window->getDisplay(), mPixmap, EGL_BACK_BUFFER);
+    glViewport(0, 0, getWindowWidth(), getWindowHeight());
+    ASSERT_EGL_SUCCESS();
+
+    // Redefine the texture
+    unsigned int pixelValue = 0xFFFF00FF;
+    std::vector<unsigned int> pixelData(getWindowWidth() * getWindowHeight(), pixelValue);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getWindowWidth(), getWindowHeight(), 0, GL_RGBA,
+                 GL_UNSIGNED_BYTE, &pixelData[0]);
+
+    // Draw a quad and verify that it is magenta
+    glUseProgram(mTextureProgram);
+    glUniform1i(mTextureUniformLocation, 0);
+
+    drawQuad(mTextureProgram, essl31_shaders::PositionAttrib(), 0.5f);
+    EXPECT_GL_NO_ERROR();
+
+    // Verify that magenta was drawn
+    EXPECT_PIXEL_EQ(getWindowWidth() / 2, getWindowHeight() / 2, 255, 0, 255, 255);
+
+    glDeleteTextures(1, &texture);
+}
+
+ANGLE_INSTANTIATE_TEST_ES2(PixmapTest);

src/tests/perf_tests/EGLMakeCurrentPerf.cpp

@@ -106,7 +106,7 @@ void EGLMakeCurrentPerfTest::SetUp()
                             EGL_RENDERABLE_TYPE,
                             GetParam().majorVersion == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT,
                             EGL_SURFACE_TYPE,
-                            EGL_PBUFFER_BIT,
+                            EGL_WINDOW_BIT,
                             EGL_NONE};
 
     ASSERT_TRUE(eglChooseConfig(mDisplay, configAttrs, &mConfig, 1, &numConfigs));

util/BUILD.gn

@@ -51,6 +51,8 @@ if (angle_use_x11) {
 
 if (is_fuchsia) {
   _util_sources += [
+    "fuchsia/FuchsiaPixmap.cpp",
+    "fuchsia/FuchsiaPixmap.h",
     "fuchsia/ScenicWindow.cpp",
     "fuchsia/ScenicWindow.h",
   ]

util/OSPixmap.h

@@ -26,7 +26,7 @@ class ANGLE_UTIL_EXPORT OSPixmap
     virtual bool initialize(EGLNativeDisplayType display,
                             size_t width,
                             size_t height,
-                            int depth) = 0;
+                            int nativeVisual) = 0;
 
     virtual EGLNativePixmapType getNativePixmap() const = 0;
 };

util/fuchsia/FuchsiaPixmap.cpp

+//
+// Copyright 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.
+//
+
+// FuchsiaPixmap.cpp: Implementation of OSPixmap for Fuchsia
+
+#include "util/fuchsia/FuchsiaPixmap.h"
+
+OSPixmap *CreateOSPixmap()
+{
+    return nullptr;
+}

util/fuchsia/FuchsiaPixmap.h

+//
+// Copyright 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.
+//
+
+// FuchsiaPixmap.h: Definition of the implementation of OSPixmap for Fuchsia
+
+#ifndef UTIL_FUCHSIA_FUCHSIAPIXMAP_H_
+#define UTIL_FUCHSIA_FUCHSIAPIXMAP_H_
+
+#include "util/OSPixmap.h"
+
+#endif  // UTIL_FUCHSIA_FUCHSIAPIXMAP_H_

util/x11/X11Pixmap.cpp

@@ -18,12 +18,27 @@ X11Pixmap::~X11Pixmap()
     }
 }
 
-bool X11Pixmap::initialize(EGLNativeDisplayType display, size_t width, size_t height, int depth)
+bool X11Pixmap::initialize(EGLNativeDisplayType display,
+                           size_t width,
+                           size_t height,
+                           int nativeVisual)
 {
     mDisplay = display;
 
     int screen  = DefaultScreen(mDisplay);
     Window root = RootWindow(mDisplay, screen);
+    int depth   = 0;
+
+    XVisualInfo visualTemplate;
+    visualTemplate.visualid = nativeVisual;
+
+    int numVisuals    = 0;
+    XVisualInfo *info = XGetVisualInfo(mDisplay, VisualIDMask, &visualTemplate, &numVisuals);
+    if (numVisuals == 1)
+    {
+        depth = info->depth;
+    }
+    XFree(info);
 
     mPixmap = XCreatePixmap(mDisplay, root, static_cast<unsigned int>(width),
                             static_cast<unsigned int>(height), depth);

util/x11/X11Pixmap.h

@@ -20,7 +20,10 @@ class X11Pixmap : public OSPixmap
     X11Pixmap();
     ~X11Pixmap() override;
 
-    bool initialize(EGLNativeDisplayType display, size_t width, size_t height, int depth) override;
+    bool initialize(EGLNativeDisplayType display,
+                    size_t width,
+                    size_t height,
+                    int nativeVisual) override;
 
     EGLNativePixmapType getNativePixmap() const override;