Revert "Implement EGL_ANGLE_iosurface_client_buffer"

extensions/EGL_ANGLE_iosurface_client_buffer.txt

@@ -73,30 +73,31 @@ Additions to Chapter 3 of the EGL 1.4 Specification (EGL Functions and Errors)
     "When <buftype> is EGL_IOSURFACE_ANGLE, <attrib_list> must contain all the
     following attributes under the following constraints otherwise
     EGL_BAD_PARAMETER is generated:
-      - EGL_TEXTURE_TYPE_ANGLE, and EGL_TEXTURE_INTERNAL_FORMAT_ANGLE followed
-    by OpenGL enums for texture types, and texture internal format
-    respectively.
-      - EGL_TEXTURE_FORMAT with a value of EGL_TEXTURE_RGBA
+      - EGL_TEXTURE_FORMAT, EGL_TEXTURE_TYPE_ANGLE, and
+    EGL_TEXTURE_INTERNAL_FORMAT_ANGLE followed by OpenGL enums for texture
+    formats, texture types, and texture internal format respectively.
       - EGL_WIDTH with a value between 1 and the width of <buffer>.
       - EGL_HEIGHT with a value between 1 and the width of <buffer>.
       - EGL_TEXTURE_TARGET with a value of EGL_TEXTURE_RECTANGLE_ANGLE
       - EGL_IOSURFACE_PLANE_ANGLE with a value between 0 and the number of
     planes of <buffer> (exclusive).
 
-    In addition the EGL_TEXTURE_TYPE_ANGLE and
+    In addition the EGL_TEXTURE_FORMAT, EGL_TEXTURE_TYPE_ANGLE and
     EGL_TEXTURE_INTERNAL_FORMAT_ANGLE attributes must be one of the
     combinations listed in table egl.iosurface.formats or an
     EGL_BAD_PARAMETER is generated. The combination must also be a valid
     combinations for glTexImage2D or EGL_BAD_PARAMETER is generated."
 
     ---------------------------------------------------------------------------
-    Texture Type               Texture Internal Format
+    Texture Format    Texture Type                    Texture Internal Format
     ---------------------------------------------------------------------------
-    GL_UNSIGNED_BYTE           GL_RED
-    GL_UNSIGNED_SHORT          GL_RED_INTEGER
-    GL_UNSIGNED_BYTE           GL_RG
-    GL_UNSIGNED_BYTE           GL_BGRA_EXT
-    GL_HALF_FLOAT              GL_RGBA
+    GL_RED            GL_UNSIGNED_BYTE                GL_RED
+    GL_RED            GL_UNSIGNED_SHORT               GL_R16UI
+    GL_RG             GL_UNSIGNED_BYTE                GL_RG
+    GL_BGRA           GL_UNSIGNED_INT_8_8_8_8_REV     GL_RGBA
+    GL_BGRA           GL_UNSIGNED_INT_8_8_8_8_REV     GL_RGBA
+    GL_BGRA           GL_UNSIGNED_INT_8_8_8_8_REV     GL_RGBA
+    GL_RGBA           GL_HALF_FLOAT                   GL_RGBA
     ---------------------------------------------------------------------------
     Table egl.iosurface.formats - Valid combinations of format, type and
     internal format for IOSurface-backed pbuffers.

include/EGL/eglext_angle.h

@@ -165,15 +165,6 @@ EGLAPI EGLint EGLAPIENTRY eglProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limi
 #endif
 #endif /* EGL_ANGLE_program_cache_control */
 
-#ifndef EGL_ANGLE_iosurface_client_buffer
-#define EGL_ANGLE_iosurface_client_buffer 1
-#define EGL_IOSURFACE_ANGLE 0x3454
-#define EGL_IOSURFACE_PLANE_ANGLE 0x345A
-#define EGL_TEXTURE_RECTANGLE_ANGLE 0x345B
-#define EGL_TEXTURE_TYPE_ANGLE 0x345C
-#define EGL_TEXTURE_INTERNAL_FORMAT_ANGLE 0x345D
-#endif /* EGL_ANGLE_iosurface_client_buffer */
-
 // clang-format on
 
 #endif  // INCLUDE_EGL_EGLEXT_ANGLE_

src/common/utilities.cpp

@@ -993,22 +993,6 @@ GLenum EGLImageTargetToGLTextureTarget(EGLenum eglTarget)
     }
 }
 
-GLenum EGLTextureTargetToGLTextureTarget(EGLenum eglTarget)
-{
-    switch (eglTarget)
-    {
-        case EGL_TEXTURE_2D:
-            return GL_TEXTURE_2D;
-
-        case EGL_TEXTURE_RECTANGLE_ANGLE:
-            return GL_TEXTURE_RECTANGLE_ANGLE;
-
-        default:
-            UNREACHABLE();
-            return GL_NONE;
-    }
-}
-
 GLuint EGLClientBufferToGLObjectHandle(EGLClientBuffer buffer)
 {
     return static_cast<GLuint>(reinterpret_cast<uintptr_t>(buffer));

src/common/utilities.h

@@ -153,7 +153,6 @@ namespace egl_gl
 {
 GLenum EGLCubeMapTargetToGLCubeMapTarget(EGLenum eglTarget);
 GLenum EGLImageTargetToGLTextureTarget(EGLenum eglTarget);
-GLenum EGLTextureTargetToGLTextureTarget(EGLenum eglTarget);
 GLuint EGLClientBufferToGLObjectHandle(EGLClientBuffer buffer);
 }
 

src/libANGLE/Caps.cpp

@@ -1151,8 +1151,7 @@ DisplayExtensions::DisplayExtensions()
       displayTextureShareGroup(false),
       createContextClientArrays(false),
       programCacheControl(false),
-      robustResourceInitialization(false),
-      iosurfaceClientBuffer(false)
+      robustResourceInitialization(false)
 {
 }
 
@@ -1197,7 +1196,6 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_create_context_client_arrays",              createContextClientArrays,          &extensionStrings);
     InsertExtensionString("EGL_ANGLE_program_cache_control",                     programCacheControl,                &extensionStrings);
     InsertExtensionString("EGL_ANGLE_robust_resource_initialization",            robustResourceInitialization,       &extensionStrings);
-    InsertExtensionString("EGL_ANGLE_iosurface_client_buffer",                   iosurfaceClientBuffer,              &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on

src/libANGLE/Caps.h

@@ -710,9 +710,6 @@ struct DisplayExtensions
 
     // EGL_ANGLE_robust_resource_initialization
     bool robustResourceInitialization;
-
-    // EGL_ANGLE_iosurface_client_buffer
-    bool iosurfaceClientBuffer;
 };
 
 struct DeviceExtensions

src/libANGLE/Surface.cpp

@@ -12,6 +12,8 @@
 
 #include <EGL/eglext.h>
 
+#include <iostream>
+
 #include "libANGLE/Config.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
@@ -57,7 +59,7 @@ Surface::Surface(EGLint surfaceType, const egl::Config *config, const AttributeM
       mSwapBehavior(EGL_NONE),
       mOrientation(0),
       mTexture(),
-      mColorFormat(config->renderTargetFormat),
+      mBackFormat(config->renderTargetFormat),
       mDSFormat(config->depthStencilFormat)
 {
     mPostSubBufferRequested = (attributes.get(EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_FALSE) == EGL_TRUE);
@@ -385,7 +387,7 @@ gl::Extents Surface::getAttachmentSize(const gl::ImageIndex & /*target*/) const
 
 const gl::Format &Surface::getAttachmentFormat(GLenum binding, const gl::ImageIndex &target) const
 {
-    return (binding == GL_BACK ? mColorFormat : mDSFormat);
+    return (binding == GL_BACK ? mBackFormat : mDSFormat);
 }
 
 GLsizei Surface::getAttachmentSamples(const gl::ImageIndex &target) const
@@ -445,13 +447,6 @@ PbufferSurface::PbufferSurface(rx::EGLImplFactory *implFactory,
 {
     mImplementation =
         implFactory->createPbufferFromClientBuffer(mState, buftype, clientBuffer, attribs);
-
-    if (buftype == EGL_IOSURFACE_ANGLE)
-    {
-        GLenum internalFormat = static_cast<GLenum>(attribs.get(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE));
-        GLenum type           = static_cast<GLenum>(attribs.get(EGL_TEXTURE_TYPE_ANGLE));
-        mColorFormat          = gl::Format(internalFormat, type);
-    }
 }
 
 PbufferSurface::~PbufferSurface()

src/libANGLE/Surface.h

@@ -125,8 +125,6 @@ class Surface : public gl::FramebufferAttachmentObject
 
     bool isRobustResourceInitEnabled() const { return mRobustResourceInitialization; }
 
-    const gl::Format &getBindTexImageFormat() const { return mColorFormat; }
-
   protected:
     Surface(EGLint surfaceType, const egl::Config *config, const AttributeMap &attributes);
     ~Surface() override;
@@ -177,7 +175,7 @@ class Surface : public gl::FramebufferAttachmentObject
 
     gl::BindingPointer<gl::Texture> mTexture;
 
-    gl::Format mColorFormat;
+    gl::Format mBackFormat;
     gl::Format mDSFormat;
 
   private:

src/libANGLE/Texture.cpp

@@ -1235,7 +1235,7 @@ Error Texture::bindTexImageFromSurface(const Context *context, egl::Surface *sur
     // Set the image info to the size and format of the surface
     ASSERT(mState.mTarget == GL_TEXTURE_2D || mState.mTarget == GL_TEXTURE_RECTANGLE_ANGLE);
     Extents size(surface->getWidth(), surface->getHeight(), 1);
-    ImageDesc desc(size, surface->getBindTexImageFormat(), InitState::Initialized);
+    ImageDesc desc(size, Format(surface->getConfig()->renderTargetFormat), InitState::Initialized);
     mState.setImageDesc(mState.mTarget, 0, desc);
     signalDirty(InitState::Initialized);
     return NoError();

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

@@ -45,10 +45,6 @@ class DisplayCGL : public DisplayGL
     egl::Error restoreLostDevice(const egl::Display *display) override;
 
     bool isValidNativeWindow(EGLNativeWindowType window) const override;
-    egl::Error validateClientBuffer(const egl::Config *configuration,
-                                    EGLenum buftype,
-                                    EGLClientBuffer clientBuffer,
-                                    const egl::AttributeMap &attribs) const override;
 
     egl::Error getDevice(DeviceImpl **device) override;
 
@@ -57,8 +53,6 @@ class DisplayCGL : public DisplayGL
     egl::Error waitClient(const gl::Context *context) const override;
     egl::Error waitNative(const gl::Context *context, EGLint engine) const override;
 
-    CGLContextObj getCGLContext() const;
-
   private:
     const FunctionsGL *getFunctionsGL() const override;
     egl::Error makeCurrentSurfaceless(gl::Context *context) override;

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

@@ -14,7 +14,6 @@
 
 #include "common/debug.h"
 #include "libANGLE/Display.h"
-#include "libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h"
 #include "libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.h"
 #include "libANGLE/renderer/gl/cgl/WindowSurfaceCGL.h"
 
@@ -132,9 +131,8 @@ SurfaceImpl *DisplayCGL::createPbufferFromClientBuffer(const egl::SurfaceState &
                                                        EGLClientBuffer clientBuffer,
                                                        const egl::AttributeMap &attribs)
 {
-    ASSERT(buftype == EGL_IOSURFACE_ANGLE);
-
-    return new IOSurfaceSurfaceCGL(state, this->getRenderer(), this, clientBuffer, attribs);
+    UNIMPLEMENTED();
+    return nullptr;
 }
 
 SurfaceImpl *DisplayCGL::createPixmapSurface(const egl::SurfaceState &state,
@@ -235,32 +233,12 @@ bool DisplayCGL::isValidNativeWindow(EGLNativeWindowType window) const
     return [layer isKindOfClass:[CALayer class]];
 }
 
-egl::Error DisplayCGL::validateClientBuffer(const egl::Config *configuration,
-                                            EGLenum buftype,
-                                            EGLClientBuffer clientBuffer,
-                                            const egl::AttributeMap &attribs) const
-{
-    ASSERT(buftype == EGL_IOSURFACE_ANGLE);
-
-    if (!IOSurfaceSurfaceCGL::validateAttributes(clientBuffer, attribs))
-    {
-        return egl::EglBadAttribute();
-    }
-
-    return egl::NoError();
-}
-
 std::string DisplayCGL::getVendorString() const
 {
     // TODO(cwallez) find a useful vendor string
     return "";
 }
 
-CGLContextObj DisplayCGL::getCGLContext() const
-{
-    return mContext;
-}
-
 const FunctionsGL *DisplayCGL::getFunctionsGL() const
 {
     return mFunctions;
@@ -268,7 +246,6 @@ const FunctionsGL *DisplayCGL::getFunctionsGL() const
 
 void DisplayCGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
 {
-    outExtensions->iosurfaceClientBuffer = true;
     outExtensions->surfacelessContext = true;
 
     // Contexts are virtualized so textures can be shared globally

src/libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h

-//
-// Copyright (c) 2017 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.
-//
-
-// PBufferSurfaceCGL.h: an implementation of PBuffers created from IOSurfaces using
-//                      EGL_ANGLE_iosurface_client_buffer
-
-#ifndef LIBANGLE_RENDERER_GL_CGL_IOSURFACESURFACECGL_H_
-#define LIBANGLE_RENDERER_GL_CGL_IOSURFACESURFACECGL_H_
-
-#include "libANGLE/renderer/gl/SurfaceGL.h"
-
-struct __IOSurface;
-typedef __IOSurface *IOSurfaceRef;
-
-namespace egl
-{
-class AttributeMap;
-}  // namespace gl
-
-namespace rx
-{
-
-class DisplayCGL;
-class FunctionsGL;
-class StateManagerGL;
-
-class IOSurfaceSurfaceCGL : public SurfaceGL
-{
-  public:
-    IOSurfaceSurfaceCGL(const egl::SurfaceState &state,
-                        RendererGL *renderer,
-                        DisplayCGL *display,
-                        EGLClientBuffer buffer,
-                        const egl::AttributeMap &attribs);
-    ~IOSurfaceSurfaceCGL() override;
-
-    egl::Error initialize(const egl::Display *display) override;
-    egl::Error makeCurrent() 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(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
-    void setSwapInterval(EGLint interval) override;
-
-    EGLint getWidth() const override;
-    EGLint getHeight() const override;
-
-    EGLint isPostSubBufferSupported() const override;
-    EGLint getSwapBehavior() const override;
-
-    static bool validateAttributes(EGLClientBuffer buffer, const egl::AttributeMap &attribs);
-
-  private:
-    DisplayCGL *mDisplay;
-    RendererGL *mRenderer;
-    StateManagerGL *mStateManager;
-    IOSurfaceRef mIOSurface;
-    int mWidth;
-    int mHeight;
-    int mPlane;
-    int mFormatIndex;
-};
-
-}  // namespace rx
-
-#endif  // LIBANGLE_RENDERER_GL_CGL_IOSURFACESURFACECGL_H_

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

-//
-// Copyright (c) 2015 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.
-//
-
-// PBufferSurfaceCGL.cpp: an implementation of PBuffers created from IOSurfaces using
-//                        EGL_ANGLE_iosurface_client_buffer
-
-#include "libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h"
-
-#include <IOSurface/IOSurface.h>
-#include <OpenGL/CGLIOSurface.h>
-
-#include "common/debug.h"
-#include "libANGLE/AttributeMap.h"
-#include "libANGLE/renderer/gl/FramebufferGL.h"
-#include "libANGLE/renderer/gl/FunctionsGL.h"
-#include "libANGLE/renderer/gl/RendererGL.h"
-#include "libANGLE/renderer/gl/StateManagerGL.h"
-#include "libANGLE/renderer/gl/TextureGL.h"
-#include "libANGLE/renderer/gl/cgl/DisplayCGL.h"
-
-namespace rx
-{
-
-namespace
-{
-
-struct IOSurfaceFormatInfo
-{
-    GLenum internalFormat;
-    GLenum type;
-
-    size_t componentBytes;
-
-    GLenum nativeInternalFormat;
-    GLenum nativeFormat;
-    GLenum nativeType;
-};
-
-// clang-format off
-static const IOSurfaceFormatInfo kIOSurfaceFormats[] = {
-    {GL_RED,      GL_UNSIGNED_BYTE,  1, GL_RED,  GL_RED,  GL_UNSIGNED_BYTE           },
-    {GL_R8UI,     GL_UNSIGNED_SHORT, 2, GL_RED,  GL_RED,  GL_UNSIGNED_SHORT          },
-    {GL_RG,       GL_UNSIGNED_BYTE,  2, GL_RG,   GL_RG,   GL_UNSIGNED_BYTE           },
-    {GL_BGRA_EXT, GL_UNSIGNED_BYTE,  4, GL_BGRA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
-    {GL_RGBA,     GL_HALF_FLOAT,     8, GL_RGBA, GL_RGBA, GL_HALF_FLOAT              },
-};
-// clang-format on
-
-int FindIOSurfaceFormatIndex(GLenum internalFormat, GLenum type)
-{
-    for (int i = 0; i < static_cast<int>(ArraySize(kIOSurfaceFormats)); ++i)
-    {
-        const auto &formatInfo = kIOSurfaceFormats[i];
-        if (formatInfo.internalFormat == internalFormat && formatInfo.type == type)
-        {
-            return i;
-        }
-    }
-    return -1;
-}
-
-}  // anonymous namespace
-
-IOSurfaceSurfaceCGL::IOSurfaceSurfaceCGL(const egl::SurfaceState &state,
-                                         RendererGL *renderer,
-                                         DisplayCGL *display,
-                                         EGLClientBuffer buffer,
-                                         const egl::AttributeMap &attribs)
-    : SurfaceGL(state, renderer),
-      mDisplay(display),
-      mRenderer(renderer),
-      mStateManager(renderer->getStateManager()),
-      mIOSurface(nullptr),
-      mWidth(0),
-      mHeight(0),
-      mPlane(0),
-      mFormatIndex(-1)
-{
-    // Keep reference to the IOSurface so it doesn't get deleted while the pbuffer exists.
-    mIOSurface = reinterpret_cast<IOSurfaceRef>(buffer);
-    CFRetain(mIOSurface);
-
-    // Extract attribs useful for the call to CGLTexImageIOSurface2D
-    mWidth  = attribs.get(EGL_WIDTH);
-    mHeight = attribs.get(EGL_HEIGHT);
-    mPlane  = attribs.get(EGL_IOSURFACE_PLANE_ANGLE);
-
-    EGLAttrib internalFormat = attribs.get(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE);
-    EGLAttrib type           = attribs.get(EGL_TEXTURE_TYPE_ANGLE);
-    mFormatIndex             = FindIOSurfaceFormatIndex(internalFormat, type);
-    ASSERT(mFormatIndex >= 0);
-}
-
-IOSurfaceSurfaceCGL::~IOSurfaceSurfaceCGL()
-{
-    if (mIOSurface != nullptr)
-    {
-        CFRelease(mIOSurface);
-        mIOSurface = nullptr;
-    }
-}
-
-egl::Error IOSurfaceSurfaceCGL::initialize(const egl::Display *display)
-{
-    return egl::NoError();
-}
-
-egl::Error IOSurfaceSurfaceCGL::makeCurrent()
-{
-    // Make current is not supported on IOSurface pbuffers.
-    return egl::EglBadSurface();
-}
-
-egl::Error IOSurfaceSurfaceCGL::swap(const gl::Context *context)
-{
-    UNREACHABLE();
-    return egl::NoError();
-}
-
-egl::Error IOSurfaceSurfaceCGL::postSubBuffer(const gl::Context *context,
-                                              EGLint x,
-                                              EGLint y,
-                                              EGLint width,
-                                              EGLint height)
-{
-    UNREACHABLE();
-    return egl::NoError();
-}
-
-egl::Error IOSurfaceSurfaceCGL::querySurfacePointerANGLE(EGLint attribute, void **value)
-{
-    UNREACHABLE();
-    return egl::NoError();
-}
-
-egl::Error IOSurfaceSurfaceCGL::bindTexImage(gl::Texture *texture, EGLint buffer)
-{
-    const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
-    GLuint textureID           = textureGL->getTextureID();
-    mStateManager->bindTexture(GL_TEXTURE_RECTANGLE, textureID);
-
-    const auto &format = kIOSurfaceFormats[mFormatIndex];
-    auto error         = CGLTexImageIOSurface2D(
-        mDisplay->getCGLContext(), GL_TEXTURE_RECTANGLE, format.nativeFormat, mWidth, mHeight,
-        format.nativeInternalFormat, format.nativeType, mIOSurface, mPlane);
-
-    if (error != kCGLNoError)
-    {
-        return egl::EglContextLost();
-    }
-
-    return egl::NoError();
-}
-
-egl::Error IOSurfaceSurfaceCGL::releaseTexImage(EGLint buffer)
-{
-    gl::Error error = mRenderer->flush();
-    if (error.isError())
-    {
-        return egl::EglContextLost();
-    }
-    return egl::NoError();
-}
-
-void IOSurfaceSurfaceCGL::setSwapInterval(EGLint interval)
-{
-    UNREACHABLE();
-}
-
-EGLint IOSurfaceSurfaceCGL::getWidth() const
-{
-    return mWidth;
-}
-
-EGLint IOSurfaceSurfaceCGL::getHeight() const
-{
-    return mHeight;
-}
-
-EGLint IOSurfaceSurfaceCGL::isPostSubBufferSupported() const
-{
-    UNREACHABLE();
-    return EGL_FALSE;
-}
-
-EGLint IOSurfaceSurfaceCGL::getSwapBehavior() const
-{
-    // N/A because you can't MakeCurrent an IOSurface, return any valid value.
-    return EGL_BUFFER_PRESERVED;
-}
-
-// static
-bool IOSurfaceSurfaceCGL::validateAttributes(EGLClientBuffer buffer,
-                                             const egl::AttributeMap &attribs)
-{
-    IOSurfaceRef ioSurface = reinterpret_cast<IOSurfaceRef>(buffer);
-
-    // The plane must exist for this IOSurface. IOSurfaceGetPlaneCount can return 0 for non-planar
-    // ioSurfaces but we will treat non-planar like it is a single plane.
-    size_t surfacePlaneCount = std::max(size_t(1), IOSurfaceGetPlaneCount(ioSurface));
-    EGLAttrib plane          = attribs.get(EGL_IOSURFACE_PLANE_ANGLE);
-    if (plane < 0 || static_cast<size_t>(plane) >= surfacePlaneCount)
-    {
-        return false;
-    }
-
-    // The width height specified must be at least (1, 1) and at most the plane size
-    EGLAttrib width  = attribs.get(EGL_WIDTH);
-    EGLAttrib height = attribs.get(EGL_HEIGHT);
-    if (width <= 0 || static_cast<size_t>(width) > IOSurfaceGetWidthOfPlane(ioSurface, plane) ||
-        height < 0 || static_cast<size_t>(height) > IOSurfaceGetHeightOfPlane(ioSurface, plane))
-    {
-        return false;
-    }
-
-    // Find this IOSurface format
-    EGLAttrib internalFormat = attribs.get(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE);
-    EGLAttrib type           = attribs.get(EGL_TEXTURE_TYPE_ANGLE);
-
-    int formatIndex = FindIOSurfaceFormatIndex(internalFormat, type);
-
-    if (formatIndex < 0)
-    {
-        return false;
-    }
-
-    // Check that the format matches this IOSurface plane
-    if (IOSurfaceGetBytesPerElementOfPlane(ioSurface, plane) !=
-        kIOSurfaceFormats[formatIndex].componentBytes)
-    {
-        return false;
-    }
-
-    return true;
-}
-
-}  // namespace rx

src/libANGLE/validationEGL.cpp

@@ -1045,18 +1045,6 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display, EGLenum buftype, E
           }
           break;
 
-      case EGL_IOSURFACE_ANGLE:
-          if (!displayExtensions.iosurfaceClientBuffer)
-          {
-              return EglBadParameter() << "<buftype> EGL_IOSURFACE_ANGLE requires the "
-                                          "EGL_ANGLE_iosurface_client_buffer extension.";
-          }
-          if (buffer == nullptr)
-          {
-              return EglBadParameter() << "<buffer> must be non null";
-          }
-          break;
-
       default:
           return EglBadParameter();
     }
@@ -1068,86 +1056,55 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display, EGLenum buftype, E
 
         switch (attribute)
         {
-            case EGL_WIDTH:
-            case EGL_HEIGHT:
-                if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE &&
-                    buftype != EGL_IOSURFACE_ANGLE)
-                {
-                    return EglBadParameter()
-                           << "Width and Height are not supported for thie <buftype>";
-                }
-                if (value < 0)
-                {
-                    return EglBadParameter() << "Width and Height must be positive";
-                }
-                break;
-
-            case EGL_TEXTURE_FORMAT:
-                switch (value)
-                {
-                    case EGL_NO_TEXTURE:
-                    case EGL_TEXTURE_RGB:
-                    case EGL_TEXTURE_RGBA:
-                        break;
-                    default:
-                        return EglBadAttribute() << "Invalid value for EGL_TEXTURE_FORMAT";
-                }
-                break;
-
-            case EGL_TEXTURE_TARGET:
-                switch (value)
-                {
-                    case EGL_NO_TEXTURE:
-                    case EGL_TEXTURE_2D:
-                        break;
-                    case EGL_TEXTURE_RECTANGLE_ANGLE:
-                        if (buftype != EGL_IOSURFACE_ANGLE)
-                        {
-                            return EglBadParameter()
-                                   << "<buftype> doesn't support rectangle texture targets";
-                        }
-                        break;
-
-                    default:
-                        return EglBadAttribute() << "Invalid value for EGL_TEXTURE_TARGET";
-                }
-                break;
-
-            case EGL_MIPMAP_TEXTURE:
-                break;
+          case EGL_WIDTH:
+          case EGL_HEIGHT:
+            if (!displayExtensions.d3dShareHandleClientBuffer)
+            {
+                return EglBadParameter();
+            }
+            if (value < 0)
+            {
+                return EglBadParameter();
+            }
+            break;
 
-            case EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE:
-                if (!displayExtensions.flexibleSurfaceCompatibility)
-                {
-                    return EglBadAttribute()
-                           << "EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE cannot be used "
-                              "without EGL_ANGLE_flexible_surface_compatibility support.";
-                }
+          case EGL_TEXTURE_FORMAT:
+            switch (value)
+            {
+              case EGL_NO_TEXTURE:
+              case EGL_TEXTURE_RGB:
+              case EGL_TEXTURE_RGBA:
                 break;
+              default:
+                  return EglBadAttribute();
+            }
+            break;
 
-            case EGL_IOSURFACE_PLANE_ANGLE:
-                if (buftype != EGL_IOSURFACE_ANGLE)
-                {
-                    return EglBadAttribute() << "<buftype> doesn't support iosurface plane";
-                }
+          case EGL_TEXTURE_TARGET:
+            switch (value)
+            {
+              case EGL_NO_TEXTURE:
+              case EGL_TEXTURE_2D:
                 break;
+              default:
+                  return EglBadAttribute();
+            }
+            break;
 
-            case EGL_TEXTURE_TYPE_ANGLE:
-                if (buftype != EGL_IOSURFACE_ANGLE)
-                {
-                    return EglBadAttribute() << "<buftype> doesn't support texture type";
-                }
-                break;
+          case EGL_MIPMAP_TEXTURE:
+            break;
 
-            case EGL_TEXTURE_INTERNAL_FORMAT_ANGLE:
-                if (buftype != EGL_IOSURFACE_ANGLE)
-                {
-                    return EglBadAttribute() << "<buftype> doesn't support texture internal format";
-                }
-                break;
+          case EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE:
+              if (!displayExtensions.flexibleSurfaceCompatibility)
+              {
+                  return EglBadAttribute()
+                         << "EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE cannot be used "
+                            "without EGL_ANGLE_flexible_surface_compatibility support.";
+              }
+              break;
 
-            default:
-                return EglBadAttribute();
+          default:
+              return EglBadAttribute();
         }
     }
 
@@ -1163,20 +1120,11 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display, EGLenum buftype, E
     {
         return EglBadMatch();
     }
-    if ((textureFormat == EGL_TEXTURE_RGB && config->bindToTextureRGB != EGL_TRUE) ||
+
+    if ((textureFormat == EGL_TEXTURE_RGB  && config->bindToTextureRGB  != EGL_TRUE) ||
         (textureFormat == EGL_TEXTURE_RGBA && config->bindToTextureRGBA != EGL_TRUE))
     {
-        // TODO(cwallez@chromium.org): For IOSurface pbuffers we require that EGL_TEXTURE_RGBA is
-        // set so that eglBinTexImage works. Normally this is only allowed if the config exposes the
-        // bindToTextureRGB/RGBA flag. This issue is that enabling this flags means that
-        // eglBindTexImage should also work for regular pbuffers which isn't implemented on macOS.
-        // Instead of adding the flag we special case the check here to be ignored for IOSurfaces.
-        // The TODO is to find a proper solution for this, maybe by implementing eglBindTexImage on
-        // OSX?
-        if (buftype != EGL_IOSURFACE_ANGLE)
-        {
-            return EglBadAttribute();
-        }
+        return EglBadAttribute();
     }
 
     if (buftype == EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE)
@@ -1196,28 +1144,6 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display, EGLenum buftype, E
         }
     }
 
-    if (buftype == EGL_IOSURFACE_ANGLE)
-    {
-        if (textureTarget != EGL_TEXTURE_RECTANGLE_ANGLE)
-        {
-            return EglBadAttribute() << "EGL_IOSURFACE requires the EGL_TEXTURE_RECTANGLE target";
-        }
-
-        if (textureFormat != EGL_TEXTURE_RGBA)
-        {
-            return EglBadAttribute() << "EGL_IOSURFACE requires the EGL_TEXTURE_RGBA format";
-        }
-
-        if (!attributes.contains(EGL_WIDTH) || !attributes.contains(EGL_HEIGHT) ||
-            !attributes.contains(EGL_TEXTURE_FORMAT) ||
-            !attributes.contains(EGL_TEXTURE_TYPE_ANGLE) ||
-            !attributes.contains(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE) ||
-            !attributes.contains(EGL_IOSURFACE_PLANE_ANGLE))
-        {
-            return EglBadParameter() << "Missing required attribute for EGL_IOSURFACE";
-        }
-    }
-
     ANGLE_TRY(display->validateClientBuffer(config, buftype, buffer, attributes));
 
     return NoError();

src/libGLESv2.gypi

@@ -696,8 +696,6 @@
         [
             'libANGLE/renderer/gl/cgl/DisplayCGL.mm',
             'libANGLE/renderer/gl/cgl/DisplayCGL.h',
-            'libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.mm',
-            'libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h',
             'libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.mm',
             'libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.h',
             'libANGLE/renderer/gl/cgl/WindowSurfaceCGL.mm',

src/libGLESv2/entry_points_egl.cpp

@@ -9,7 +9,6 @@
 #include "libGLESv2/entry_points_egl.h"
 
 #include "common/debug.h"
-#include "common/utilities.h"
 #include "common/version.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
@@ -761,8 +760,7 @@ EGLBoolean EGLAPIENTRY BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint b
     gl::Context *context = thread->getContext();
     if (context)
     {
-        GLenum target = egl_gl::EGLTextureTargetToGLTextureTarget(eglSurface->getTextureTarget());
-        gl::Texture *textureObject = context->getTargetTexture(target);
+        gl::Texture *textureObject = context->getTargetTexture(GL_TEXTURE_2D);
         ASSERT(textureObject != nullptr);
 
         if (textureObject->getImmutableFormat())

src/tests/BUILD.gn

@@ -129,17 +129,7 @@ if (is_win || is_linux || is_mac || is_android) {
 
     sources =
         rebase_path(end2end_gypi.angle_end2end_tests_sources, ".", "../..")
-    libs = []
 
-    if (is_mac) {
-      sources += rebase_path(end2end_gypi.angle_end2end_tests_mac_sources,
-                             ".",
-                             "../..")
-      libs += [
-        "CoreFoundation.framework",
-        "IOSurface.framework",
-      ]
-    }
     if (is_win) {
       sources += rebase_path(end2end_gypi.angle_end2end_tests_win_sources,
                              ".",

src/tests/angle_end2end_tests.gypi

@@ -114,10 +114,6 @@
             '<(angle_path)/src/tests/test_utils/angle_test_instantiate.h',
             '<(angle_path)/src/tests/test_utils/gl_raii.h',
         ],
-        'angle_end2end_tests_mac_sources':
-        [
-            '<(angle_path)/src/tests/egl_tests/EGLIOSurfaceClientBufferTest.cpp',
-        ],
         'angle_end2end_tests_win_sources':
         [
             '<(angle_path)/src/tests/gl_tests/D3DImageFormatConversionTest.cpp',
@@ -157,21 +153,6 @@
     ],
     'conditions':
     [
-        ['OS=="mac"',
-        {
-            'sources':
-            [
-                '<@(angle_end2end_tests_mac_sources)',
-            ],
-            'link_settings':
-            {
-                'libraries':
-                [
-                    '$(SDKROOT)/System/Library/Frameworks/CoreFoundation.framework',
-                    '$(SDKROOT)/System/Library/Frameworks/IOSurface.framework',
-                ],
-            },
-        }],
         ['OS=="win"',
         {
             'sources':

src/tests/egl_tests/EGLIOSurfaceClientBufferTest.cpp

-//
-// Copyright 2017 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.
-//
-//    EGLIOSurfaceClientBufferTest.cpp: tests for the EGL_ANGLE_iosurface_client_buffer extension.
-//
-
-#include "test_utils/ANGLETest.h"
-#include "test_utils/gl_raii.h"
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <IOSurface/IOSurface.h>
-
-#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
-
-using namespace angle;
-
-namespace
-{
-
-void AddIntegerValue(CFMutableDictionaryRef dictionary, const CFStringRef key, int32_t value)
-{
-    CFNumberRef number = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value);
-    CFDictionaryAddValue(dictionary, key, number);
-    CFRelease(number);
-}
-
-}  // anonymous namespace
-
-class IOSurfaceClientBufferTest : public ANGLETest
-{
-  protected:
-    IOSurfaceClientBufferTest() : mConfig(0), mDisplay(nullptr) {}
-
-    void SetUp() override
-    {
-        ANGLETest::SetUp();
-
-        mConfig  = getEGLWindow()->getConfig();
-        mDisplay = getEGLWindow()->getDisplay();
-    }
-
-    void TearDown() override { ANGLETest::TearDown(); }
-
-    EGLConfig mConfig;
-    EGLDisplay mDisplay;
-};
-
-TEST_P(IOSurfaceClientBufferTest, RenderToBGRA8888IOSurface)
-{
-    // Create a 1 by 1 BGRA8888 IOSurface
-    IOSurfaceRef ioSurface = nullptr;
-
-    CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
-        kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
-    AddIntegerValue(dict, kIOSurfaceWidth, 1);
-    AddIntegerValue(dict, kIOSurfaceHeight, 1);
-    AddIntegerValue(dict, kIOSurfacePixelFormat, 'BGRA');
-    AddIntegerValue(dict, kIOSurfaceBytesPerElement, 4);
-
-    ioSurface = IOSurfaceCreate(dict);
-    CFRelease(dict);
-
-    EXPECT_NE(nullptr, ioSurface);
-
-    // Make a PBuffer from it using the EGL_ANGLE_iosurface_client_buffer extension
-    // clang-format off
-    const EGLint attribs[] = {
-        EGL_WIDTH,                         1,
-        EGL_HEIGHT,                        1,
-        EGL_IOSURFACE_PLANE_ANGLE,         0,
-        EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
-        EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
-        EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
-        EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
-        EGL_NONE,                          EGL_NONE,
-    };
-    // clang-format off
-
-    EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(mDisplay, EGL_IOSURFACE_ANGLE, ioSurface, mConfig, attribs);
-    EXPECT_NE(EGL_NO_SURFACE, pbuffer);
-
-    // Bind and glClear the pbuffer
-    GLTexture tex;
-    glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
-    EGLBoolean result = eglBindTexImage(mDisplay, pbuffer, EGL_BACK_BUFFER);
-    EXPECT_EGL_TRUE(result);
-    EXPECT_EGL_SUCCESS();
-
-    GLFramebuffer fbo;
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-    EXPECT_GL_NO_ERROR();
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex, 0);
-    EXPECT_GL_NO_ERROR();
-    EXPECT_GLENUM_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GL_FRAMEBUFFER_COMPLETE);
-    EXPECT_GL_NO_ERROR();
-
-    glClearColor(0, 1, 0, 1);
-    EXPECT_GL_NO_ERROR();
-    glClear(GL_COLOR_BUFFER_BIT);
-    EXPECT_GL_NO_ERROR();
-
-    // Unbind pbuffer and check content.
-    result = eglReleaseTexImage(mDisplay, pbuffer, EGL_BACK_BUFFER);
-    EXPECT_EGL_TRUE(result);
-    EXPECT_EGL_SUCCESS();
-
-    IOSurfaceLock(ioSurface, kIOSurfaceLockReadOnly, nullptr);
-    GLColor color = *reinterpret_cast<const GLColor*>(IOSurfaceGetBaseAddress(ioSurface));
-    IOSurfaceUnlock(ioSurface, kIOSurfaceLockReadOnly, nullptr);
-
-    CFRelease(ioSurface);
-
-    EXPECT_EQ(color, GLColor::green);
-}
-
-ANGLE_INSTANTIATE_TEST(IOSurfaceClientBufferTest, ES3_OPENGL());