Add an extension to share textures at the display level.

extensions/EGL_ANGLE_display_texture_share_group.txt

+Name
+
+    ANGLE_display_texture_share_group
+
+Name Strings
+
+    EGL_ANGLE_display_texture_share_group
+
+Contributors
+
+    Geoff Lang, Google
+
+Contacts
+
+    Geoff Lang, Google (geofflang 'at' google.com)
+
+Status
+
+    Draft
+
+Version
+
+    Version 1, February 7, 2017
+
+Number
+
+    EGL Extension TBD
+
+Dependencies
+
+    This extension is written against the wording of the EGL 1.5 specification.
+
+Overview
+
+    This extension allows for the creation of OpenGL ES contexts that share
+    texture objects with other contexts owned by the same display. This method
+    of sharing textures can be used in conjuction with regular share groups.
+
+New Types
+
+    None
+
+New Procedures and Functions
+
+    None
+
+New Tokens
+
+    Accepted as an attribute name in the <*attrib_list> argument to
+    eglCreateContext:
+
+        EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE    0x33AF
+
+Additions to the EGL 1.5 Specification
+
+    Add a new section entitled "OpenGL ES Global Texture Share Groups"
+    to section 3.7.1:
+
+    "If the attribute EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE is set to EGL_TRUE,
+    a context that shares textures with other contexts owned by the same
+    display and created with EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE set to
+    EGL_TRUE will be created. If the share_context parameter to
+    eglCreateContext is not NULL, all contexts within the share group must have
+    been created with the same value of EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE.
+    The default value of EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE is EGL_FALSE."
+
+Issues
+
+    None
+
+Revision History
+
+    Version 1, 2017/02/07 - first draft.

include/EGL/eglext.h

@@ -650,6 +650,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamPostD3DTextureNV12ANGLE(EGLDisplay dpy, E
 #define EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE 0x3AAC
 #endif /* EGL_ANGLE_create_context_webgl_compatibility */
 
+#ifndef EGL_ANGLE_display_texture_share_group
+#define EGL_ANGLE_display_texture_share_group 1
+#define EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE 0x3AAF
+#endif /* EGL_ANGLE_display_texture_share_group */
+
 #ifndef EGL_CHROMIUM_create_context_bind_generates_resource
 #define EGL_CHROMIUM_create_context_bind_generates_resource 1
 #define EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM 0x3AAD

src/libANGLE/Caps.cpp

@@ -1032,7 +1032,8 @@ DisplayExtensions::DisplayExtensions()
       createContextBindGeneratesResource(false),
       swapBuffersWithDamage(false),
       pixelFormatFloat(false),
-      surfacelessContext(false)
+      surfacelessContext(false),
+      displayTextureShareGroup(false)
 {
 }
 
@@ -1072,6 +1073,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_EXT_swap_buffers_with_damage",                    swapBuffersWithDamage,              &extensionStrings);
     InsertExtensionString("EGL_EXT_pixel_format_float",                          pixelFormatFloat,                   &extensionStrings);
     InsertExtensionString("EGL_KHR_surfaceless_context",                         surfacelessContext,                 &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_display_texture_share_group",               displayTextureShareGroup,            &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on

src/libANGLE/Caps.h

@@ -646,6 +646,9 @@ struct DisplayExtensions
 
     // EGL_KHR_surfaceless_context
     bool surfacelessContext;
+
+    // EGL_ANGLE_display_texture_share_group
+    bool displayTextureShareGroup;
 };
 
 struct DeviceExtensions

src/libANGLE/Context.cpp

@@ -236,10 +236,12 @@ namespace gl
 Context::Context(rx::EGLImplFactory *implFactory,
                  const egl::Config *config,
                  const Context *shareContext,
+                 TextureManager *shareTextures,
                  const egl::AttributeMap &attribs,
                  const egl::DisplayExtensions &displayExtensions)
 
     : ValidationContext(shareContext,
+                        shareTextures,
                         GetClientVersion(attribs),
                         &mGLState,
                         mCaps,

src/libANGLE/Context.h

@@ -61,6 +61,7 @@ class Context final : public ValidationContext
     Context(rx::EGLImplFactory *implFactory,
             const egl::Config *config,
             const Context *shareContext,
+            TextureManager *shareTextures,
             const egl::AttributeMap &attribs,
             const egl::DisplayExtensions &displayExtensions);
 

src/libANGLE/ContextState.cpp

@@ -36,10 +36,34 @@ T *AllocateOrGetSharedResourceManager(const ContextState *shareContextState,
     }
 }
 
+TextureManager *AllocateOrGetSharedTextureManager(const ContextState *shareContextState,
+                                                  TextureManager *shareTextures,
+                                                  ContextStateMember<TextureManager> member)
+{
+    if (shareContextState)
+    {
+        TextureManager *textureManager = (*shareContextState).*member;
+        ASSERT(shareTextures == nullptr || textureManager == shareTextures);
+        textureManager->addRef();
+        return textureManager;
+    }
+    else if (shareTextures)
+    {
+        TextureManager *textureManager = shareTextures;
+        textureManager->addRef();
+        return textureManager;
+    }
+    else
+    {
+        return new TextureManager();
+    }
+}
+
 }  // anonymous namespace
 
 ContextState::ContextState(uintptr_t contextIn,
                            const ContextState *shareContextState,
+                           TextureManager *shareTextures,
                            const Version &clientVersion,
                            State *stateIn,
                            const Caps &capsIn,
@@ -56,7 +80,9 @@ ContextState::ContextState(uintptr_t contextIn,
       mBuffers(AllocateOrGetSharedResourceManager(shareContextState, &ContextState::mBuffers)),
       mShaderPrograms(
           AllocateOrGetSharedResourceManager(shareContextState, &ContextState::mShaderPrograms)),
-      mTextures(AllocateOrGetSharedResourceManager(shareContextState, &ContextState::mTextures)),
+      mTextures(AllocateOrGetSharedTextureManager(shareContextState,
+                                                  shareTextures,
+                                                  &ContextState::mTextures)),
       mRenderbuffers(
           AllocateOrGetSharedResourceManager(shareContextState, &ContextState::mRenderbuffers)),
       mSamplers(AllocateOrGetSharedResourceManager(shareContextState, &ContextState::mSamplers)),
@@ -85,6 +111,7 @@ const TextureCaps &ContextState::getTextureCap(GLenum internalFormat) const
 }
 
 ValidationContext::ValidationContext(const ValidationContext *shareContext,
+                                     TextureManager *shareTextures,
                                      const Version &clientVersion,
                                      State *state,
                                      const Caps &caps,
@@ -94,13 +121,15 @@ ValidationContext::ValidationContext(const ValidationContext *shareContext,
                                      bool skipValidation)
     : mState(reinterpret_cast<uintptr_t>(this),
              shareContext ? &shareContext->mState : nullptr,
+             shareTextures,
              clientVersion,
              state,
              caps,
              textureCaps,
              extensions,
              limitations),
-      mSkipValidation(skipValidation)
+      mSkipValidation(skipValidation),
+      mDisplayTextureShareGroup(shareTextures != nullptr)
 {
 }
 
@@ -673,4 +702,9 @@ bool ValidationContext::isFramebufferGenerated(GLuint framebuffer) const
     return mState.mFramebuffers->isFramebufferGenerated(framebuffer);
 }
 
+bool ValidationContext::usingDisplayTextureShareGroup() const
+{
+    return mDisplayTextureShareGroup;
+}
+
 }  // namespace gl

src/libANGLE/ContextState.h

@@ -35,6 +35,7 @@ class ContextState final : public angle::NonCopyable
   public:
     ContextState(uintptr_t context,
                  const ContextState *shareContextState,
+                 TextureManager *shareTextures,
                  const Version &clientVersion,
                  State *state,
                  const Caps &caps,
@@ -55,6 +56,8 @@ class ContextState final : public angle::NonCopyable
 
     const TextureCaps &getTextureCap(GLenum internalFormat) const;
 
+    bool usingDisplayTextureShareGroup() const;
+
   private:
     friend class Context;
     friend class ValidationContext;
@@ -81,6 +84,7 @@ class ValidationContext : angle::NonCopyable
 {
   public:
     ValidationContext(const ValidationContext *shareContext,
+                      TextureManager *shareTextures,
                       const Version &clientVersion,
                       State *state,
                       const Caps &caps,
@@ -115,9 +119,12 @@ class ValidationContext : angle::NonCopyable
     bool isRenderbufferGenerated(GLuint renderbuffer) const;
     bool isFramebufferGenerated(GLuint framebuffer) const;
 
+    bool usingDisplayTextureShareGroup() const;
+
   protected:
     ContextState mState;
     bool mSkipValidation;
+    bool mDisplayTextureShareGroup;
 };
 }  // namespace gl
 

src/libANGLE/Display.cpp

@@ -29,6 +29,7 @@
 #include "libANGLE/Image.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/Stream.h"
+#include "libANGLE/ResourceManager.h"
 #include "libANGLE/renderer/DisplayImpl.h"
 #include "libANGLE/renderer/ImageImpl.h"
 #include "third_party/trace_event/trace_event.h"
@@ -358,7 +359,8 @@ Display::Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDe
       mDisplayExtensionString(),
       mVendorString(),
       mDevice(eglDevice),
-      mPlatform(platform)
+      mPlatform(platform),
+      mTextureManager(nullptr)
 {
 }
 
@@ -462,6 +464,9 @@ Error Display::initialize()
         ASSERT(mDevice != nullptr);
     }
 
+    ASSERT(mTextureManager == nullptr);
+    mTextureManager = new gl::TextureManager();
+
     mInitialized = true;
 
     return egl::Error(EGL_SUCCESS);
@@ -469,6 +474,12 @@ Error Display::initialize()
 
 void Display::terminate()
 {
+    if (mTextureManager)
+    {
+        mTextureManager->release();
+        mTextureManager = nullptr;
+    }
+
     makeCurrent(nullptr, nullptr, nullptr);
 
     while (!mContextSet.empty())
@@ -673,8 +684,12 @@ Error Display::createContext(const Config *configuration, gl::Context *shareCont
         ANGLE_TRY(restoreLostDevice());
     }
 
-    gl::Context *context =
-        new gl::Context(mImplementation, configuration, shareContext, attribs, mDisplayExtensions);
+    bool usingDisplayTextureShareGroup =
+        attribs.get(EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE, EGL_FALSE) == EGL_TRUE;
+    gl::TextureManager *shareTextures = usingDisplayTextureShareGroup ? mTextureManager : nullptr;
+
+    gl::Context *context = new gl::Context(mImplementation, configuration, shareContext,
+                                           shareTextures, attribs, mDisplayExtensions);
 
     ASSERT(context != nullptr);
     mContextSet.insert(context);

src/libANGLE/Display.h

@@ -24,6 +24,7 @@
 namespace gl
 {
 class Context;
+class TextureManager;
 }
 
 namespace rx
@@ -172,6 +173,8 @@ class Display final : angle::NonCopyable
     Device *mDevice;
     EGLenum mPlatform;
     angle::LoggingAnnotator mAnnotator;
+
+    gl::TextureManager *mTextureManager;
 };
 
 }

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -1099,6 +1099,9 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions
 
     outExtensions->flexibleSurfaceCompatibility = true;
     outExtensions->directComposition            = !!mDCompModule;
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 gl::Error Renderer11::flush()

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -540,6 +540,9 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions)
     outExtensions->glRenderbufferImage = true;
 
     outExtensions->flexibleSurfaceCompatibility = true;
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 void Renderer9::startScene()

src/libANGLE/renderer/gl/cgl/DisplayCGL.mm

@@ -246,6 +246,9 @@ const FunctionsGL *DisplayCGL::getFunctionsGL() const
 void DisplayCGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
 {
     outExtensions->surfacelessContext = true;
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 void DisplayCGL::generateCaps(egl::Caps *outCaps) const

src/libANGLE/renderer/gl/egl/DisplayEGL.cpp

@@ -102,6 +102,9 @@ void DisplayEGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
         mEGL->hasExtension("EGL_EXT_create_context_robustness");
 
     outExtensions->postSubBuffer = false;  // Since SurfaceEGL::postSubBuffer is not implemented
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 void DisplayEGL::generateCaps(egl::Caps *outCaps) const

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

@@ -891,6 +891,9 @@ const FunctionsGL *DisplayGLX::getFunctionsGL() const
 void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const
 {
     outExtensions->createContextRobustness = mHasARBCreateContextRobustness;
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 void DisplayGLX::generateCaps(egl::Caps *outCaps) const

src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp

@@ -660,6 +660,9 @@ void DisplayWGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
     outExtensions->createContextRobustness = mHasRobustness;
 
     outExtensions->d3dTextureClientBuffer = mFunctionsWGL->hasExtension("WGL_NV_DX_interop2");
+
+    // Contexts are virtualized so textures can be shared globally
+    outExtensions->displayTextureShareGroup = true;
 }
 
 void DisplayWGL::generateCaps(egl::Caps *outCaps) const

src/libANGLE/validationEGL.cpp

@@ -427,8 +427,30 @@ Error ValidateCreateContext(Display *display, Config *configuration, gl::Context
               }
               break;
 
+          case EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE:
+              if (!display->getExtensions().displayTextureShareGroup)
+              {
+                  return Error(EGL_BAD_ATTRIBUTE,
+                               "Attribute EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE requires "
+                               "EGL_ANGLE_display_texture_share_group.");
+              }
+              if (value != EGL_TRUE && value != EGL_FALSE)
+              {
+                  return Error(
+                      EGL_BAD_ATTRIBUTE,
+                      "EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE must be EGL_TRUE or EGL_FALSE.");
+              }
+              if (shareContext &&
+                  (shareContext->usingDisplayTextureShareGroup() != (value == EGL_TRUE)))
+              {
+                  return Error(EGL_BAD_ATTRIBUTE,
+                               "All contexts within a share group must be created with the same "
+                               "value of EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE.");
+              }
+              break;
+
           default:
-            return Error(EGL_BAD_ATTRIBUTE);
+              return Error(EGL_BAD_ATTRIBUTE, "Unknown attribute.");
         }
     }
 

src/libANGLE/validationES_unittest.cpp

@@ -31,6 +31,7 @@ class MockValidationContext : public ValidationContext
 {
   public:
     MockValidationContext(const ValidationContext *shareContext,
+                          TextureManager *shareTextures,
                           const Version &version,
                           State *state,
                           const Caps &caps,
@@ -39,6 +40,7 @@ class MockValidationContext : public ValidationContext
                           const Limitations &limitations,
                           bool skipValidation)
         : ValidationContext(shareContext,
+                            shareTextures,
                             version,
                             state,
                             caps,
@@ -97,8 +99,8 @@ TEST(ValidationESTest, DrawElementsWithMaxIndexGivesError)
     state.setDrawFramebufferBinding(framebuffer);
     state.setProgram(program);
 
-    NiceMock<MockValidationContext> testContext(nullptr, Version(3, 0), &state, caps, textureCaps,
-                                                extensions, limitations, false);
+    NiceMock<MockValidationContext> testContext(nullptr, nullptr, Version(3, 0), &state, caps,
+                                                textureCaps, extensions, limitations, false);
 
     // Set the expectation for the validation error here.
     Error expectedError(GL_INVALID_OPERATION, g_ExceedsMaxElementErrorMessage);

src/tests/egl_tests/EGLContextSharingTest.cpp

@@ -82,6 +82,128 @@ TEST_P(EGLContextSharingTest, BindTextureAfterShareContextFree)
     ASSERT_GL_NO_ERROR();
 }
 
+// Tests the creation of contexts using EGL_ANGLE_display_texture_share_group
+TEST_P(EGLContextSharingTest, DisplayShareGroupContextCreation)
+{
+    EGLDisplay display = getEGLWindow()->getDisplay();
+    EGLConfig config   = getEGLWindow()->getConfig();
+
+    const EGLint inShareGroupContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2, EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE, EGL_TRUE, EGL_NONE};
+
+    // Test creating two contexts in the global share group
+    mContexts[0] = eglCreateContext(display, config, nullptr, inShareGroupContextAttribs);
+    mContexts[1] = eglCreateContext(display, config, mContexts[1], inShareGroupContextAttribs);
+
+    if (!ANGLETest::eglDisplayExtensionEnabled(display, "EGL_ANGLE_display_texture_share_group"))
+    {
+        // Make sure an error is generated and early-exit
+        ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE);
+        ASSERT_EQ(EGL_NO_CONTEXT, mContexts[0]);
+        return;
+    }
+
+    ASSERT_EGL_SUCCESS();
+
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[0]);
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[1]);
+    eglDestroyContext(display, mContexts[0]);
+
+    // Try creating a context that is not in the global share group but tries to share with a
+    // context that is
+    const EGLint notInShareGroupContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2, EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE, EGL_FALSE, EGL_NONE};
+    mContexts[1] = eglCreateContext(display, config, mContexts[1], notInShareGroupContextAttribs);
+    ASSERT_EGL_ERROR(EGL_BAD_ATTRIBUTE);
+    ASSERT_TRUE(mContexts[1] == EGL_NO_CONTEXT);
+}
+
+// Tests the sharing of textures using EGL_ANGLE_display_texture_share_group
+TEST_P(EGLContextSharingTest, DisplayShareGroupObjectSharing)
+{
+    EGLDisplay display = getEGLWindow()->getDisplay();
+    if (!ANGLETest::eglDisplayExtensionEnabled(display, "EGL_ANGLE_display_texture_share_group"))
+    {
+        std::cout << "Test skipped because EGL_ANGLE_display_texture_share_group is not present."
+                  << std::endl;
+        return;
+    }
+
+    EGLConfig config   = getEGLWindow()->getConfig();
+    EGLSurface surface = getEGLWindow()->getSurface();
+
+    const EGLint inShareGroupContextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2, EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE, EGL_TRUE, EGL_NONE};
+
+    // Create two contexts in the global share group but not in the same context share group
+    mContexts[0] = eglCreateContext(display, config, nullptr, inShareGroupContextAttribs);
+    mContexts[1] = eglCreateContext(display, config, nullptr, inShareGroupContextAttribs);
+
+    ASSERT_EGL_SUCCESS();
+
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[0]);
+    ASSERT_NE(EGL_NO_CONTEXT, mContexts[1]);
+
+    ASSERT_EGL_TRUE(eglMakeCurrent(display, surface, surface, mContexts[0]));
+    ASSERT_EGL_SUCCESS();
+
+    // Create a texture and buffer in ctx 0
+    GLuint textureFromCtx0 = 0;
+    glGenTextures(1, &textureFromCtx0);
+    glBindTexture(GL_TEXTURE_2D, textureFromCtx0);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    ASSERT_GL_TRUE(glIsTexture(textureFromCtx0));
+
+    GLuint bufferFromCtx0 = 0;
+    glGenBuffers(1, &bufferFromCtx0);
+    glBindBuffer(GL_ARRAY_BUFFER, bufferFromCtx0);
+    glBufferData(GL_ARRAY_BUFFER, 1, nullptr, GL_STATIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    ASSERT_GL_TRUE(glIsBuffer(bufferFromCtx0));
+
+    ASSERT_GL_NO_ERROR();
+
+    // Switch to context 1 and verify that the texture is accessible but the buffer is not
+    ASSERT_EGL_TRUE(eglMakeCurrent(display, surface, surface, mContexts[1]));
+    ASSERT_EGL_SUCCESS();
+
+    ASSERT_GL_TRUE(glIsTexture(textureFromCtx0));
+
+    ASSERT_GL_FALSE(glIsBuffer(bufferFromCtx0));
+    glDeleteBuffers(1, &bufferFromCtx0);
+    ASSERT_GL_NO_ERROR();
+
+    // Call readpixels on the texture to verify that the backend has proper support
+    GLuint fbo = 0;
+    glGenFramebuffers(1, &fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureFromCtx0, 0);
+
+    GLubyte pixel[4];
+    glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
+    ASSERT_GL_NO_ERROR();
+
+    glDeleteFramebuffers(1, &fbo);
+
+    glDeleteTextures(1, &textureFromCtx0);
+    ASSERT_GL_NO_ERROR();
+    ASSERT_GL_FALSE(glIsTexture(textureFromCtx0));
+
+    // Switch back to context 0 and delete the buffer
+    ASSERT_EGL_TRUE(eglMakeCurrent(display, surface, surface, mContexts[0]));
+    ASSERT_EGL_SUCCESS();
+
+    ASSERT_GL_TRUE(glIsBuffer(bufferFromCtx0));
+    glDeleteBuffers(1, &bufferFromCtx0);
+    ASSERT_GL_NO_ERROR();
+}
+
 }  // anonymous namespace
 
-ANGLE_INSTANTIATE_TEST(EGLContextSharingTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(EGLContextSharingTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL());

src/tests/test_utils/ANGLETest.h

@@ -21,6 +21,11 @@
 #include "shader_utils.h"
 #include "system_utils.h"
 
+#define ASSERT_GL_TRUE(a) ASSERT_EQ(static_cast<GLboolean>(GL_TRUE), (a))
+#define ASSERT_GL_FALSE(a) ASSERT_EQ(static_cast<GLboolean>(GL_FALSE), (a))
+#define EXPECT_GL_TRUE(a) EXPECT_EQ(static_cast<GLboolean>(GL_TRUE), (a))
+#define EXPECT_GL_FALSE(a) EXPECT_EQ(static_cast<GLboolean>(GL_FALSE), (a))
+
 #define EXPECT_GL_ERROR(err) EXPECT_EQ(static_cast<GLenum>(err), glGetError())
 #define EXPECT_GL_NO_ERROR() EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError())