Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3933 insertions, 0 deletions

diff --git a/gfx/angle/checkout/src/libANGLE/validationEGL.cpp b/gfx/angle/checkout/src/libANGLE/validationEGL.cpp
new file mode 100644
index 0000000000..105afc64d0
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/validationEGL.cpp
@@ -0,0 +1,3933 @@
+//
+// Copyright (c) 2016 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.
+//
+
+// validationEGL.cpp: Validation functions for generic EGL entry point parameters
+
+#include "libANGLE/validationEGL.h"
+
+#include "common/utilities.h"
+#include "libANGLE/Config.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Device.h"
+#include "libANGLE/Display.h"
+#include "libANGLE/EGLSync.h"
+#include "libANGLE/Image.h"
+#include "libANGLE/Stream.h"
+#include "libANGLE/Surface.h"
+#include "libANGLE/Texture.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/formatutils.h"
+
+#include <EGL/eglext.h>
+
+namespace egl
+{
+namespace
+{
+size_t GetMaximumMipLevel(const gl::Context *context, gl::TextureType type)
+{
+    const gl::Caps &caps = context->getCaps();
+
+    size_t maxDimension = 0;
+    switch (type)
+    {
+        case gl::TextureType::_2D:
+        case gl::TextureType::_2DArray:
+        case gl::TextureType::_2DMultisample:
+            maxDimension = caps.max2DTextureSize;
+            break;
+        case gl::TextureType::Rectangle:
+            maxDimension = caps.maxRectangleTextureSize;
+            break;
+        case gl::TextureType::CubeMap:
+            maxDimension = caps.maxCubeMapTextureSize;
+            break;
+        case gl::TextureType::_3D:
+            maxDimension = caps.max3DTextureSize;
+            break;
+
+        default:
+            UNREACHABLE();
+    }
+
+    return gl::log2(static_cast<int>(maxDimension));
+}
+
+bool TextureHasNonZeroMipLevelsSpecified(const gl::Context *context, const gl::Texture *texture)
+{
+    size_t maxMip = GetMaximumMipLevel(context, texture->getType());
+    for (size_t level = 1; level < maxMip; level++)
+    {
+        if (texture->getType() == gl::TextureType::CubeMap)
+        {
+            for (gl::TextureTarget face : gl::AllCubeFaceTextureTargets())
+            {
+                if (texture->getFormat(face, level).valid())
+                {
+                    return true;
+                }
+            }
+        }
+        else
+        {
+            if (texture->getFormat(gl::NonCubeTextureTypeToTarget(texture->getType()), level)
+                    .valid())
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool CubeTextureHasUnspecifiedLevel0Face(const gl::Texture *texture)
+{
+    ASSERT(texture->getType() == gl::TextureType::CubeMap);
+    for (gl::TextureTarget face : gl::AllCubeFaceTextureTargets())
+    {
+        if (!texture->getFormat(face, 0).valid())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+Error ValidateStreamAttribute(const EGLAttrib attribute,
+                              const EGLAttrib value,
+                              const DisplayExtensions &extensions)
+{
+    switch (attribute)
+    {
+        case EGL_STREAM_STATE_KHR:
+        case EGL_PRODUCER_FRAME_KHR:
+        case EGL_CONSUMER_FRAME_KHR:
+            return EglBadAccess() << "Attempt to initialize readonly parameter";
+        case EGL_CONSUMER_LATENCY_USEC_KHR:
+            // Technically not in spec but a latency < 0 makes no sense so we check it
+            if (value < 0)
+            {
+                return EglBadParameter() << "Latency must be positive";
+            }
+            break;
+        case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
+            if (!extensions.streamConsumerGLTexture)
+            {
+                return EglBadAttribute() << "Consumer GL extension not enabled";
+            }
+            // Again not in spec but it should be positive anyways
+            if (value < 0)
+            {
+                return EglBadParameter() << "Timeout must be positive";
+            }
+            break;
+        default:
+            return EglBadAttribute() << "Invalid stream attribute";
+    }
+    return NoError();
+}
+
+Error ValidateCreateImageMipLevelCommon(gl::Context *context,
+                                        const gl::Texture *texture,
+                                        EGLAttrib level)
+{
+    // Note that the spec EGL_create_image spec does not explicitly specify an error
+    // when the level is outside the base/max level range, but it does mention that the
+    // level "must be a part of the complete texture object <buffer>". It can be argued
+    // that out-of-range levels are not a part of the complete texture.
+    const GLuint effectiveBaseLevel = texture->getTextureState().getEffectiveBaseLevel();
+    if (level > 0 &&
+        (!texture->isMipmapComplete() || static_cast<GLuint>(level) < effectiveBaseLevel ||
+         static_cast<GLuint>(level) > texture->getTextureState().getMipmapMaxLevel()))
+    {
+        return EglBadParameter() << "texture must be complete if level is non-zero.";
+    }
+
+    if (level == 0 && !texture->isMipmapComplete() &&
+        TextureHasNonZeroMipLevelsSpecified(context, texture))
+    {
+        return EglBadParameter() << "if level is zero and the texture is incomplete, it must "
+                                    "have no mip levels specified except zero.";
+    }
+
+    return NoError();
+}
+
+Error ValidateConfigAttribute(const Display *display, EGLAttrib attribute)
+{
+    switch (attribute)
+    {
+        case EGL_BUFFER_SIZE:
+        case EGL_ALPHA_SIZE:
+        case EGL_BLUE_SIZE:
+        case EGL_GREEN_SIZE:
+        case EGL_RED_SIZE:
+        case EGL_DEPTH_SIZE:
+        case EGL_STENCIL_SIZE:
+        case EGL_CONFIG_CAVEAT:
+        case EGL_CONFIG_ID:
+        case EGL_LEVEL:
+        case EGL_NATIVE_RENDERABLE:
+        case EGL_NATIVE_VISUAL_ID:
+        case EGL_NATIVE_VISUAL_TYPE:
+        case EGL_SAMPLES:
+        case EGL_SAMPLE_BUFFERS:
+        case EGL_SURFACE_TYPE:
+        case EGL_TRANSPARENT_TYPE:
+        case EGL_TRANSPARENT_BLUE_VALUE:
+        case EGL_TRANSPARENT_GREEN_VALUE:
+        case EGL_TRANSPARENT_RED_VALUE:
+        case EGL_BIND_TO_TEXTURE_RGB:
+        case EGL_BIND_TO_TEXTURE_RGBA:
+        case EGL_MIN_SWAP_INTERVAL:
+        case EGL_MAX_SWAP_INTERVAL:
+        case EGL_LUMINANCE_SIZE:
+        case EGL_ALPHA_MASK_SIZE:
+        case EGL_COLOR_BUFFER_TYPE:
+        case EGL_RENDERABLE_TYPE:
+        case EGL_MATCH_NATIVE_PIXMAP:
+        case EGL_CONFORMANT:
+        case EGL_MAX_PBUFFER_WIDTH:
+        case EGL_MAX_PBUFFER_HEIGHT:
+        case EGL_MAX_PBUFFER_PIXELS:
+            break;
+
+        case EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE:
+            if (!display->getExtensions().surfaceOrientation)
+            {
+                return EglBadAttribute() << "EGL_ANGLE_surface_orientation is not enabled.";
+            }
+            break;
+
+        case EGL_COLOR_COMPONENT_TYPE_EXT:
+            if (!display->getExtensions().pixelFormatFloat)
+            {
+                return EglBadAttribute() << "EGL_EXT_pixel_format_float is not enabled.";
+            }
+            break;
+
+        case EGL_RECORDABLE_ANDROID:
+            if (!display->getExtensions().recordable)
+            {
+                return EglBadAttribute() << "EGL_ANDROID_recordable is not enabled.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "Unknown attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateConfigAttributeValue(const Display *display, EGLAttrib attribute, EGLAttrib value)
+{
+    switch (attribute)
+    {
+
+        case EGL_BIND_TO_TEXTURE_RGB:
+        case EGL_BIND_TO_TEXTURE_RGBA:
+            switch (value)
+            {
+                case EGL_DONT_CARE:
+                case EGL_TRUE:
+                case EGL_FALSE:
+                    break;
+                default:
+                    return EglBadAttribute() << "EGL_bind_to_texture invalid attribute: " << value;
+            }
+            break;
+
+        case EGL_COLOR_BUFFER_TYPE:
+            switch (value)
+            {
+                case EGL_RGB_BUFFER:
+                case EGL_LUMINANCE_BUFFER:
+                // EGL_DONT_CARE doesn't match the spec, but does match dEQP usage
+                case EGL_DONT_CARE:
+                    break;
+                default:
+                    return EglBadAttribute()
+                           << "EGL_color_buffer_type invalid attribute: " << value;
+            }
+            break;
+
+        case EGL_NATIVE_RENDERABLE:
+            switch (value)
+            {
+                case EGL_DONT_CARE:
+                case EGL_TRUE:
+                case EGL_FALSE:
+                    break;
+                default:
+                    return EglBadAttribute()
+                           << "EGL_native_renderable invalid attribute: " << value;
+            }
+            break;
+
+        case EGL_TRANSPARENT_TYPE:
+            switch (value)
+            {
+                case EGL_NONE:
+                case EGL_TRANSPARENT_RGB:
+                // EGL_DONT_CARE doesn't match the spec, but does match dEQP usage
+                case EGL_DONT_CARE:
+                    break;
+                default:
+                    return EglBadAttribute() << "EGL_transparent_type invalid attribute: " << value;
+            }
+            break;
+
+        case EGL_RECORDABLE_ANDROID:
+            switch (value)
+            {
+                case EGL_TRUE:
+                case EGL_FALSE:
+                case EGL_DONT_CARE:
+                    break;
+                default:
+                    return EglBadAttribute()
+                           << "EGL_RECORDABLE_ANDROID invalid attribute: " << value;
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    return NoError();
+}
+
+Error ValidateConfigAttributes(const Display *display, const AttributeMap &attributes)
+{
+    for (const auto &attrib : attributes)
+    {
+        ANGLE_TRY(ValidateConfigAttribute(display, attrib.first));
+        ANGLE_TRY(ValidateConfigAttributeValue(display, attrib.first, attrib.second));
+    }
+
+    return NoError();
+}
+
+Error ValidatePlatformType(const ClientExtensions &clientExtensions, EGLAttrib platformType)
+{
+    switch (platformType)
+    {
+        case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
+            break;
+
+        case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
+        case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
+            if (!clientExtensions.platformANGLED3D)
+            {
+                return EglBadAttribute() << "Direct3D platform is unsupported.";
+            }
+            break;
+
+        case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+        case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
+            if (!clientExtensions.platformANGLEOpenGL)
+            {
+                return EglBadAttribute() << "OpenGL platform is unsupported.";
+            }
+            break;
+
+        case EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE:
+            if (!clientExtensions.platformANGLENULL)
+            {
+                return EglBadAttribute() << "Display type EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE "
+                                            "requires EGL_ANGLE_platform_angle_null.";
+            }
+            break;
+
+        case EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE:
+            if (!clientExtensions.platformANGLEVulkan)
+            {
+                return EglBadAttribute() << "Vulkan platform is unsupported.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "Unknown platform type.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetPlatformDisplayCommon(EGLenum platform,
+                                       void *native_display,
+                                       const AttributeMap &attribMap)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+
+    switch (platform)
+    {
+        case EGL_PLATFORM_ANGLE_ANGLE:
+            if (!clientExtensions.platformANGLE)
+            {
+                return EglBadParameter() << "Platform ANGLE extension is not active";
+            }
+            break;
+        case EGL_PLATFORM_DEVICE_EXT:
+            if (!clientExtensions.platformDevice)
+            {
+                return EglBadParameter() << "Platform Device extension is not active";
+            }
+            break;
+        default:
+            return EglBadConfig() << "Bad platform type.";
+    }
+
+    if (platform == EGL_PLATFORM_ANGLE_ANGLE)
+    {
+        EGLAttrib platformType       = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+        bool enableAutoTrimSpecified = false;
+        bool presentPathSpecified    = false;
+
+        Optional<EGLAttrib> majorVersion;
+        Optional<EGLAttrib> minorVersion;
+        Optional<EGLAttrib> deviceType;
+        Optional<EGLAttrib> eglHandle;
+
+        for (const auto &curAttrib : attribMap)
+        {
+            const EGLAttrib value = curAttrib.second;
+
+            switch (curAttrib.first)
+            {
+                case EGL_PLATFORM_ANGLE_TYPE_ANGLE:
+                {
+                    ANGLE_TRY(ValidatePlatformType(clientExtensions, value));
+                    platformType = value;
+                    break;
+                }
+
+                case EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE:
+                    if (value != EGL_DONT_CARE)
+                    {
+                        majorVersion = value;
+                    }
+                    break;
+
+                case EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE:
+                    if (value != EGL_DONT_CARE)
+                    {
+                        minorVersion = value;
+                    }
+                    break;
+
+                case EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE:
+                    switch (value)
+                    {
+                        case EGL_TRUE:
+                        case EGL_FALSE:
+                            break;
+                        default:
+                            return EglBadAttribute() << "Invalid automatic trim attribute";
+                    }
+                    enableAutoTrimSpecified = true;
+                    break;
+
+                case EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE:
+                    if (!clientExtensions.experimentalPresentPath)
+                    {
+                        return EglBadAttribute()
+                               << "EGL_ANGLE_experimental_present_path extension not active";
+                    }
+
+                    switch (value)
+                    {
+                        case EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE:
+                        case EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE:
+                            break;
+                        default:
+                            return EglBadAttribute()
+                                   << "Invalid value for EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE";
+                    }
+                    presentPathSpecified = true;
+                    break;
+
+                case EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE:
+                    switch (value)
+                    {
+                        case EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE:
+                        case EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE:
+                            break;
+
+                        case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE:
+                        case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE:
+                            if (!clientExtensions.platformANGLED3D)
+                            {
+                                return EglBadAttribute()
+                                       << "EGL_ANGLE_platform_angle_d3d is not supported";
+                            }
+                            break;
+
+                        default:
+                            return EglBadAttribute() << "Invalid value for "
+                                                        "EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE "
+                                                        "attrib";
+                    }
+                    deviceType = value;
+                    break;
+
+                case EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE:
+                    if (!clientExtensions.platformANGLE)
+                    {
+                        return EglBadAttribute() << "EGL_ANGLE_platform_angle extension not active";
+                    }
+                    if (value != EGL_TRUE && value != EGL_FALSE && value != EGL_DONT_CARE)
+                    {
+                        return EglBadAttribute() << "EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE "
+                                                    "must be EGL_TRUE, EGL_FALSE, or "
+                                                    "EGL_DONT_CARE.";
+                    }
+                    break;
+
+                case EGL_PLATFORM_ANGLE_EGL_HANDLE_ANGLE:
+                    if (value != EGL_DONT_CARE)
+                    {
+                        eglHandle = value;
+                    }
+                    break;
+
+                case EGL_PLATFORM_ANGLE_CONTEXT_VIRTUALIZATION_ANGLE:
+                    if (!clientExtensions.platformANGLEContextVirtualization)
+                    {
+                        return EglBadAttribute() << "EGL_ANGLE_platform_angle_context_"
+                                                    "virtualization extension not active";
+                    }
+
+                    switch (value)
+                    {
+                        case EGL_DONT_CARE:
+                        case EGL_FALSE:
+                        case EGL_TRUE:
+                            break;
+
+                        default:
+                            return EglBadAttribute() << "Invalid value for "
+                                                        "EGL_PLATFORM_ANGLE_CONTEXT_VIRTUALIZATION_"
+                                                        "ANGLE attrib";
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        if (!majorVersion.valid() && minorVersion.valid())
+        {
+            return EglBadAttribute()
+                   << "Must specify major version if you specify a minor version.";
+        }
+
+        if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE &&
+            platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+        {
+            return EglBadAttribute() << "EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE requires a "
+                                        "device type of EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.";
+        }
+
+        if (enableAutoTrimSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+        {
+            return EglBadAttribute() << "EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE "
+                                        "requires a device type of "
+                                        "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.";
+        }
+
+        if (presentPathSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+        {
+            return EglBadAttribute() << "EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE requires a "
+                                        "device type of EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE.";
+        }
+
+        if (deviceType.valid())
+        {
+            switch (deviceType.value())
+            {
+                case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_REFERENCE_ANGLE:
+                case EGL_PLATFORM_ANGLE_DEVICE_TYPE_D3D_WARP_ANGLE:
+                    if (platformType != EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE &&
+                        platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+                    {
+                        return EglBadAttribute()
+                               << "This device type requires a "
+                                  "platform type of EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE or "
+                                  "EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE.";
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if (platformType == EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE)
+        {
+            if ((majorVersion.valid() && majorVersion.value() != 1) ||
+                (minorVersion.valid() && minorVersion.value() != 0))
+            {
+                return EglBadAttribute() << "EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE currently "
+                                            "only supports Vulkan 1.0.";
+            }
+        }
+
+        if (eglHandle.valid() && platformType != EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE &&
+            platformType != EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE)
+        {
+            return EglBadAttribute() << "EGL_PLATFORM_ANGLE_EGL_HANDLE_ANGLE requires a "
+                                        "device type of EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE.";
+        }
+    }
+    else if (platform == EGL_PLATFORM_DEVICE_EXT)
+    {
+        Device *eglDevice = static_cast<Device *>(native_display);
+        if (eglDevice == nullptr || !Device::IsValidDevice(eglDevice))
+        {
+            return EglBadAttribute() << "native_display should be a valid EGL device if "
+                                        "platform equals EGL_PLATFORM_DEVICE_EXT";
+        }
+    }
+    else
+    {
+        UNREACHABLE();
+    }
+
+    if (attribMap.contains(EGL_FEATURE_OVERRIDES_ENABLED_ANGLE))
+    {
+        if (!clientExtensions.featureControlANGLE)
+        {
+            return EglBadAttribute() << "EGL_ANGLE_feature_control is not supported";
+        }
+        else if (attribMap.get(EGL_FEATURE_OVERRIDES_ENABLED_ANGLE, 0) == 0)
+        {
+            return EglBadAttribute()
+                   << "EGL_FEATURE_OVERRIDES_ENABLED_ANGLE must be a valid pointer";
+        }
+    }
+    if (attribMap.contains(EGL_FEATURE_OVERRIDES_DISABLED_ANGLE))
+    {
+        if (!clientExtensions.featureControlANGLE)
+        {
+            return EglBadAttribute() << "EGL_ANGLE_feature_control is not supported";
+        }
+        else if (attribMap.get(EGL_FEATURE_OVERRIDES_DISABLED_ANGLE, 0) == 0)
+        {
+            return EglBadAttribute()
+                   << "EGL_FEATURE_OVERRIDES_DISABLED_ANGLE must be a valid pointer";
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateStream(const Display *display, const Stream *stream)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.stream)
+    {
+        return EglBadAccess() << "Stream extension not active";
+    }
+
+    if (stream == EGL_NO_STREAM_KHR || !display->isValidStream(stream))
+    {
+        return EglBadStream() << "Invalid stream";
+    }
+
+    return NoError();
+}
+
+Error ValidateLabeledObject(Thread *thread,
+                            const Display *display,
+                            ObjectType objectType,
+                            EGLObjectKHR object,
+                            LabeledObject **outLabeledObject)
+{
+    switch (objectType)
+    {
+        case ObjectType::Context:
+        {
+            gl::Context *context = static_cast<gl::Context *>(object);
+            ANGLE_TRY(ValidateContext(display, context));
+            *outLabeledObject = context;
+            break;
+        }
+
+        case ObjectType::Display:
+        {
+            ANGLE_TRY(ValidateDisplay(display));
+            if (display != object)
+            {
+                return EglBadParameter() << "when object type is EGL_OBJECT_DISPLAY_KHR, the "
+                                            "object must be the same as the display.";
+            }
+
+            *outLabeledObject = static_cast<Display *>(object);
+            break;
+        }
+
+        case ObjectType::Image:
+        {
+            Image *image = static_cast<Image *>(object);
+            ANGLE_TRY(ValidateImage(display, image));
+            *outLabeledObject = image;
+            break;
+        }
+
+        case ObjectType::Stream:
+        {
+            Stream *stream = static_cast<Stream *>(object);
+            ANGLE_TRY(ValidateStream(display, stream));
+            *outLabeledObject = stream;
+            break;
+        }
+
+        case ObjectType::Surface:
+        {
+            Surface *surface = static_cast<Surface *>(object);
+            ANGLE_TRY(ValidateSurface(display, surface));
+            *outLabeledObject = surface;
+            break;
+        }
+
+        case ObjectType::Sync:
+        {
+            Sync *sync = static_cast<Sync *>(object);
+            ANGLE_TRY(ValidateSync(display, sync));
+            *outLabeledObject = sync;
+            break;
+        }
+
+        case ObjectType::Thread:
+        {
+            *outLabeledObject = thread;
+            break;
+        }
+
+        default:
+            return EglBadParameter() << "unknown object type.";
+    }
+
+    return NoError();
+}
+
+// This is a common sub-check of Display status that's shared by multiple functions
+Error ValidateDisplayPointer(const Display *display)
+{
+    if (display == EGL_NO_DISPLAY)
+    {
+        return EglBadDisplay() << "display is EGL_NO_DISPLAY.";
+    }
+
+    if (!Display::isValidDisplay(display))
+    {
+        return EglBadDisplay() << "display is not a valid display.";
+    }
+
+    return NoError();
+}
+
+bool ValidCompositorTimingName(CompositorTiming name)
+{
+    switch (name)
+    {
+        case CompositorTiming::CompositeDeadline:
+        case CompositorTiming::CompositInterval:
+        case CompositorTiming::CompositToPresentLatency:
+            return true;
+
+        default:
+            return false;
+    }
+}
+
+bool ValidTimestampType(Timestamp timestamp)
+{
+    switch (timestamp)
+    {
+        case Timestamp::RequestedPresentTime:
+        case Timestamp::RenderingCompleteTime:
+        case Timestamp::CompositionLatchTime:
+        case Timestamp::FirstCompositionStartTime:
+        case Timestamp::LastCompositionStartTime:
+        case Timestamp::FirstCompositionGPUFinishedTime:
+        case Timestamp::DisplayPresentTime:
+        case Timestamp::DequeueReadyTime:
+        case Timestamp::ReadsDoneTime:
+            return true;
+
+        default:
+            return false;
+    }
+}
+
+}  // anonymous namespace
+
+Error ValidateDisplay(const Display *display)
+{
+    ANGLE_TRY(ValidateDisplayPointer(display));
+
+    if (!display->isInitialized())
+    {
+        return EglNotInitialized() << "display is not initialized.";
+    }
+
+    if (display->isDeviceLost())
+    {
+        return EglContextLost() << "display had a context loss";
+    }
+
+    return NoError();
+}
+
+Error ValidateSurface(const Display *display, const Surface *surface)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->isValidSurface(surface))
+    {
+        return EglBadSurface();
+    }
+
+    return NoError();
+}
+
+Error ValidateConfig(const Display *display, const Config *config)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->isValidConfig(config))
+    {
+        return EglBadConfig();
+    }
+
+    return NoError();
+}
+
+Error ValidateContext(const Display *display, const gl::Context *context)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->isValidContext(context))
+    {
+        return EglBadContext();
+    }
+
+    return NoError();
+}
+
+Error ValidateImage(const Display *display, const Image *image)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->isValidImage(image))
+    {
+        return EglBadParameter() << "image is not valid.";
+    }
+
+    return NoError();
+}
+
+Error ValidateDevice(const Device *device)
+{
+    if (device == EGL_NO_DEVICE_EXT)
+    {
+        return EglBadAccess() << "device is EGL_NO_DEVICE.";
+    }
+
+    if (!Device::IsValidDevice(device))
+    {
+        return EglBadAccess() << "device is not valid.";
+    }
+
+    return NoError();
+}
+
+Error ValidateSync(const Display *display, const Sync *sync)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->isValidSync(sync))
+    {
+        return EglBadParameter() << "sync object is not valid.";
+    }
+
+    return NoError();
+}
+
+const Thread *GetThreadIfValid(const Thread *thread)
+{
+    // Threads should always be valid
+    return thread;
+}
+
+const Display *GetDisplayIfValid(const Display *display)
+{
+    if (ValidateDisplay(display).isError())
+    {
+        return nullptr;
+    }
+
+    return display;
+}
+
+const Surface *GetSurfaceIfValid(const Display *display, const Surface *surface)
+{
+    if (ValidateSurface(display, surface).isError())
+    {
+        return nullptr;
+    }
+
+    return surface;
+}
+
+const Image *GetImageIfValid(const Display *display, const Image *image)
+{
+    if (ValidateImage(display, image).isError())
+    {
+        return nullptr;
+    }
+
+    return image;
+}
+
+const Stream *GetStreamIfValid(const Display *display, const Stream *stream)
+{
+    if (ValidateStream(display, stream).isError())
+    {
+        return nullptr;
+    }
+
+    return stream;
+}
+
+const gl::Context *GetContextIfValid(const Display *display, const gl::Context *context)
+{
+    if (ValidateContext(display, context).isError())
+    {
+        return nullptr;
+    }
+
+    return context;
+}
+
+const Device *GetDeviceIfValid(const Device *device)
+{
+    if (ValidateDevice(device).isError())
+    {
+        return nullptr;
+    }
+
+    return device;
+}
+
+const Sync *GetSyncIfValid(const Display *display, const Sync *sync)
+{
+    if (ValidateSync(display, sync).isError())
+    {
+        return nullptr;
+    }
+
+    return sync;
+}
+
+LabeledObject *GetLabeledObjectIfValid(Thread *thread,
+                                       const Display *display,
+                                       ObjectType objectType,
+                                       EGLObjectKHR object)
+{
+    LabeledObject *labeledObject = nullptr;
+    if (ValidateLabeledObject(thread, display, objectType, object, &labeledObject).isError())
+    {
+        return nullptr;
+    }
+
+    return labeledObject;
+}
+
+Error ValidateInitialize(const Display *display)
+{
+    return ValidateDisplayPointer(display);
+}
+
+Error ValidateTerminate(const Display *display)
+{
+    return ValidateDisplayPointer(display);
+}
+
+Error ValidateCreateContext(Display *display,
+                            Config *configuration,
+                            gl::Context *shareContext,
+                            const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateConfig(display, configuration));
+
+    // Get the requested client version (default is 1) and check it is 2 or 3.
+    EGLAttrib clientMajorVersion = 1;
+    EGLAttrib clientMinorVersion = 0;
+    EGLAttrib contextFlags       = 0;
+    bool resetNotification       = false;
+    for (AttributeMap::const_iterator attributeIter = attributes.begin();
+         attributeIter != attributes.end(); attributeIter++)
+    {
+        EGLAttrib attribute = attributeIter->first;
+        EGLAttrib value     = attributeIter->second;
+
+        switch (attribute)
+        {
+            case EGL_CONTEXT_CLIENT_VERSION:
+                clientMajorVersion = value;
+                break;
+
+            case EGL_CONTEXT_MINOR_VERSION:
+                clientMinorVersion = value;
+                break;
+
+            case EGL_CONTEXT_FLAGS_KHR:
+                contextFlags = value;
+                break;
+
+            case EGL_CONTEXT_OPENGL_DEBUG:
+                break;
+
+            case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
+                // Only valid for OpenGL (non-ES) contexts
+                return EglBadAttribute();
+
+            case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
+                if (!display->getExtensions().createContextRobustness)
+                {
+                    return EglBadAttribute();
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
+                return EglBadAttribute()
+                       << "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR is not"
+                       << " valid for GLES with EGL 1.4 and KHR_create_context. Use"
+                       << " EXT_create_context_robustness.";
+            case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
+                if (!display->getExtensions().createContextRobustness)
+                {
+                    return EglBadAttribute();
+                }
+                if (value == EGL_LOSE_CONTEXT_ON_RESET_EXT)
+                {
+                    resetNotification = true;
+                }
+                else if (value != EGL_NO_RESET_NOTIFICATION_EXT)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_CONTEXT_OPENGL_NO_ERROR_KHR:
+                if (!display->getExtensions().createContextNoError)
+                {
+                    return EglBadAttribute() << "Invalid Context attribute.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "Attribute must be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE:
+                if (!display->getExtensions().createContextWebGLCompatibility)
+                {
+                    return EglBadAttribute() << "Attribute "
+                                                "EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE requires "
+                                                "EGL_ANGLE_create_context_webgl_compatibility.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE must be "
+                                                "EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM:
+                if (!display->getExtensions().createContextBindGeneratesResource)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM requires "
+                              "EGL_CHROMIUM_create_context_bind_generates_resource.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_CONTEXT_BIND_GENERATES_RESOURCE_CHROMIUM "
+                                                "must be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE:
+                if (!display->getExtensions().displayTextureShareGroup)
+                {
+                    return EglBadAttribute() << "Attribute "
+                                                "EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE requires "
+                                                "EGL_ANGLE_display_texture_share_group.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE must be "
+                                                "EGL_TRUE or EGL_FALSE.";
+                }
+                if (shareContext &&
+                    (shareContext->usingDisplayTextureShareGroup() != (value == EGL_TRUE)))
+                {
+                    return EglBadAttribute() << "All contexts within a share group must be "
+                                                "created with the same value of "
+                                                "EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE.";
+                }
+                break;
+
+            case EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE:
+                if (!display->getExtensions().createContextClientArrays)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE requires "
+                              "EGL_ANGLE_create_context_client_arrays.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE must "
+                                                "be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE:
+                if (!display->getExtensions().programCacheControl)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE "
+                              "requires EGL_ANGLE_program_cache_control.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute()
+                           << "EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE must "
+                              "be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+                if (!display->getExtensions().robustResourceInitialization)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                              "requires EGL_ANGLE_robust_resource_initialization.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                                "either EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_EXTENSIONS_ENABLED_ANGLE:
+                if (!display->getExtensions().createContextExtensionsEnabled)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_EXTENSIONS_ENABLED_ANGLE "
+                              "requires EGL_ANGLE_create_context_extensions_enabled.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_EXTENSIONS_ENABLED_ANGLE must be "
+                                                "either EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_POWER_PREFERENCE_ANGLE:
+                if (!display->getExtensions().powerPreference)
+                {
+                    return EglBadAttribute() << "Attribute EGL_POWER_PREFERENCE_ANGLE "
+                                                "requires EGL_ANGLE_power_preference.";
+                }
+                if (value != EGL_LOW_POWER_ANGLE && value != EGL_HIGH_POWER_ANGLE)
+                {
+                    return EglBadAttribute()
+                           << "EGL_POWER_PREFERENCE_ANGLE must be "
+                              "either EGL_LOW_POWER_ANGLE or EGL_HIGH_POWER_ANGLE.";
+                }
+                break;
+
+            case EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE:
+                if (!display->getExtensions().createContextBackwardsCompatible)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE "
+                              "requires EGL_ANGLE_create_context_backwards_compatible.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute()
+                           << "EGL_CONTEXT_OPENGL_BACKWARDS_COMPATIBLE_ANGLE must be "
+                              "either EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            default:
+                return EglBadAttribute() << "Unknown attribute.";
+        }
+    }
+
+    switch (clientMajorVersion)
+    {
+        case 1:
+            if (clientMinorVersion != 0 && clientMinorVersion != 1)
+            {
+                return EglBadConfig();
+            }
+            break;
+
+        case 2:
+            if (clientMinorVersion != 0)
+            {
+                return EglBadConfig();
+            }
+            break;
+        case 3:
+            if (clientMinorVersion != 0 && clientMinorVersion != 1)
+            {
+                return EglBadConfig();
+            }
+            if (!(configuration->renderableType & EGL_OPENGL_ES3_BIT_KHR))
+            {
+                return EglBadConfig();
+            }
+            if (display->getMaxSupportedESVersion() <
+                gl::Version(static_cast<GLuint>(clientMajorVersion),
+                            static_cast<GLuint>(clientMinorVersion)))
+            {
+                return EglBadConfig() << "Requested GLES version is not supported.";
+            }
+            break;
+        default:
+            return EglBadConfig();
+            break;
+    }
+
+    // Note: EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR does not apply to ES
+    const EGLint validContextFlags =
+        (EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR | EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR);
+    if ((contextFlags & ~validContextFlags) != 0)
+    {
+        return EglBadAttribute();
+    }
+
+    if (shareContext)
+    {
+        // Shared context is invalid or is owned by another display
+        if (!display->isValidContext(shareContext))
+        {
+            return EglBadMatch();
+        }
+
+        if (shareContext->isResetNotificationEnabled() != resetNotification)
+        {
+            return EglBadMatch();
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateWindowSurface(Display *display,
+                                  Config *config,
+                                  EGLNativeWindowType window,
+                                  const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateConfig(display, config));
+
+    if (!display->isValidNativeWindow(window))
+    {
+        return EglBadNativeWindow();
+    }
+
+    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_RENDER_BUFFER:
+                switch (value)
+                {
+                    case EGL_BACK_BUFFER:
+                        break;
+                    case EGL_SINGLE_BUFFER:
+                        return EglBadMatch();  // Rendering directly to front buffer not supported
+                    default:
+                        return EglBadAttribute();
+                }
+                break;
+
+            case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
+                if (!displayExtensions.postSubBuffer)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE:
+                if (!displayExtensions.flexibleSurfaceCompatibility)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_WIDTH:
+            case EGL_HEIGHT:
+                if (!displayExtensions.windowFixedSize)
+                {
+                    return EglBadAttribute();
+                }
+                if (value < 0)
+                {
+                    return EglBadParameter();
+                }
+                break;
+
+            case EGL_FIXED_SIZE_ANGLE:
+                if (!displayExtensions.windowFixedSize)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_SURFACE_ORIENTATION_ANGLE:
+                if (!displayExtensions.surfaceOrientation)
+                {
+                    return EglBadAttribute() << "EGL_ANGLE_surface_orientation is not enabled.";
+                }
+                break;
+
+            case EGL_VG_COLORSPACE:
+                return EglBadMatch();
+
+            case EGL_VG_ALPHA_FORMAT:
+                return EglBadMatch();
+
+            case EGL_DIRECT_COMPOSITION_ANGLE:
+                if (!displayExtensions.directComposition)
+                {
+                    return EglBadAttribute();
+                }
+                break;
+
+            case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+                if (!display->getExtensions().robustResourceInitialization)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                              "requires EGL_ANGLE_robust_resource_initialization.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                                "either EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            default:
+                return EglBadAttribute();
+        }
+    }
+
+    if (Display::hasExistingWindowSurface(window))
+    {
+        return EglBadAlloc();
+    }
+
+    return NoError();
+}
+
+Error ValidateCreatePbufferSurface(Display *display, Config *config, 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_WIDTH:
+            case EGL_HEIGHT:
+                if (value < 0)
+                {
+                    return EglBadParameter();
+                }
+                break;
+
+            case EGL_LARGEST_PBUFFER:
+                break;
+
+            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_TEXTURE_TARGET:
+                switch (value)
+                {
+                    case EGL_NO_TEXTURE:
+                    case EGL_TEXTURE_2D:
+                        break;
+                    default:
+                        return EglBadAttribute();
+                }
+                break;
+
+            case EGL_MIPMAP_TEXTURE:
+                break;
+
+            case EGL_VG_COLORSPACE:
+                break;
+
+            case EGL_VG_ALPHA_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;
+
+            case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+                if (!display->getExtensions().robustResourceInitialization)
+                {
+                    return EglBadAttribute()
+                           << "Attribute EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE "
+                              "requires EGL_ANGLE_robust_resource_initialization.";
+                }
+                if (value != EGL_TRUE && value != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE must be "
+                                                "either EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            default:
+                return EglBadAttribute();
+        }
+    }
+
+    if (!(config->surfaceType & EGL_PBUFFER_BIT))
+    {
+        return EglBadMatch();
+    }
+
+    const Caps &caps = display->getCaps();
+
+    EGLAttrib textureFormat = attributes.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE);
+    EGLAttrib textureTarget = attributes.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE);
+
+    if ((textureFormat != EGL_NO_TEXTURE && textureTarget == EGL_NO_TEXTURE) ||
+        (textureFormat == EGL_NO_TEXTURE && textureTarget != EGL_NO_TEXTURE))
+    {
+        return EglBadMatch();
+    }
+
+    if ((textureFormat == EGL_TEXTURE_RGB && config->bindToTextureRGB != EGL_TRUE) ||
+        (textureFormat == EGL_TEXTURE_RGBA && config->bindToTextureRGBA != EGL_TRUE))
+    {
+        return EglBadAttribute();
+    }
+
+    EGLint width  = static_cast<EGLint>(attributes.get(EGL_WIDTH, 0));
+    EGLint height = static_cast<EGLint>(attributes.get(EGL_HEIGHT, 0));
+    if (textureFormat != EGL_NO_TEXTURE && !caps.textureNPOT &&
+        (!gl::isPow2(width) || !gl::isPow2(height)))
+    {
+        return EglBadMatch();
+    }
+
+    return NoError();
+}
+
+Error ValidateCreatePbufferFromClientBuffer(Display *display,
+                                            EGLenum buftype,
+                                            EGLClientBuffer buffer,
+                                            Config *config,
+                                            const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateConfig(display, config));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+
+    switch (buftype)
+    {
+        case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
+            if (!displayExtensions.d3dShareHandleClientBuffer)
+            {
+                return EglBadParameter();
+            }
+            if (buffer == nullptr)
+            {
+                return EglBadParameter();
+            }
+            break;
+
+        case EGL_D3D_TEXTURE_ANGLE:
+            if (!displayExtensions.d3dTextureClientBuffer)
+            {
+                return EglBadParameter();
+            }
+            if (buffer == nullptr)
+            {
+                return EglBadParameter();
+            }
+            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();
+    }
+
+    for (AttributeMap::const_iterator attributeIter = attributes.begin();
+         attributeIter != attributes.end(); attributeIter++)
+    {
+        EGLAttrib attribute = attributeIter->first;
+        EGLAttrib value     = attributeIter->second;
+
+        switch (attribute)
+        {
+            case EGL_WIDTH:
+            case EGL_HEIGHT:
+                if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE &&
+                    buftype != EGL_D3D_TEXTURE_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_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;
+
+            case EGL_IOSURFACE_PLANE_ANGLE:
+                if (buftype != EGL_IOSURFACE_ANGLE)
+                {
+                    return EglBadAttribute() << "<buftype> doesn't support iosurface plane";
+                }
+                break;
+
+            case EGL_TEXTURE_TYPE_ANGLE:
+                if (buftype != EGL_IOSURFACE_ANGLE)
+                {
+                    return EglBadAttribute() << "<buftype> doesn't support texture type";
+                }
+                break;
+
+            case EGL_TEXTURE_INTERNAL_FORMAT_ANGLE:
+                if (buftype != EGL_IOSURFACE_ANGLE)
+                {
+                    return EglBadAttribute() << "<buftype> doesn't support texture internal format";
+                }
+                break;
+            case EGL_GL_COLORSPACE:
+                if (buftype != EGL_D3D_TEXTURE_ANGLE)
+                {
+                    return EglBadAttribute() << "<buftype> doesn't support setting GL colorspace";
+                }
+                break;
+            default:
+                return EglBadAttribute();
+        }
+    }
+
+    EGLAttrib colorspace = attributes.get(EGL_GL_COLORSPACE, EGL_GL_COLORSPACE_LINEAR);
+    if (colorspace != EGL_GL_COLORSPACE_LINEAR && colorspace != EGL_GL_COLORSPACE_SRGB)
+    {
+        return EglBadAttribute() << "invalid GL colorspace";
+    }
+
+    if (!(config->surfaceType & EGL_PBUFFER_BIT))
+    {
+        return EglBadMatch();
+    }
+
+    EGLAttrib textureFormat = attributes.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE);
+    EGLAttrib textureTarget = attributes.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE);
+    if ((textureFormat != EGL_NO_TEXTURE && textureTarget == EGL_NO_TEXTURE) ||
+        (textureFormat == EGL_NO_TEXTURE && textureTarget != EGL_NO_TEXTURE))
+    {
+        return EglBadMatch();
+    }
+    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 eglBindTexImage 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();
+        }
+    }
+
+    if (buftype == EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE)
+    {
+        EGLint width  = static_cast<EGLint>(attributes.get(EGL_WIDTH, 0));
+        EGLint height = static_cast<EGLint>(attributes.get(EGL_HEIGHT, 0));
+
+        if (width == 0 || height == 0)
+        {
+            return EglBadAttribute();
+        }
+
+        const Caps &caps = display->getCaps();
+        if (textureFormat != EGL_NO_TEXTURE && !caps.textureNPOT &&
+            (!gl::isPow2(width) || !gl::isPow2(height)))
+        {
+            return EglBadMatch();
+        }
+    }
+
+    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();
+}
+
+Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context)
+{
+    if (context == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
+    {
+        return EglBadMatch() << "If ctx is EGL_NO_CONTEXT, surfaces must be EGL_NO_SURFACE";
+    }
+
+    // If ctx is EGL_NO_CONTEXT and either draw or read are not EGL_NO_SURFACE, an EGL_BAD_MATCH
+    // error is generated. EGL_KHR_surfaceless_context allows both surfaces to be EGL_NO_SURFACE.
+    if (context != EGL_NO_CONTEXT && (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE))
+    {
+        if (display->getExtensions().surfacelessContext)
+        {
+            if ((draw == EGL_NO_SURFACE) != (read == EGL_NO_SURFACE))
+            {
+                return EglBadMatch() << "If ctx is not EGL_NOT_CONTEXT, draw or read must "
+                                        "both be EGL_NO_SURFACE, or both not";
+            }
+        }
+        else
+        {
+            return EglBadMatch()
+                   << "If ctx is not EGL_NO_CONTEXT, surfaces must not be EGL_NO_SURFACE";
+        }
+    }
+
+    // If either of draw or read is a valid surface and the other is EGL_NO_SURFACE, an
+    // EGL_BAD_MATCH error is generated.
+    if ((read == EGL_NO_SURFACE) != (draw == EGL_NO_SURFACE))
+    {
+        return EglBadMatch()
+               << "read and draw must both be valid surfaces, or both be EGL_NO_SURFACE";
+    }
+
+    if (display == EGL_NO_DISPLAY || !Display::isValidDisplay(display))
+    {
+        return EglBadDisplay() << "'dpy' not a valid EGLDisplay handle";
+    }
+
+    // EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
+    if (!display->isInitialized() &&
+        (context != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
+    {
+        return EglNotInitialized() << "'dpy' not initialized";
+    }
+
+    if (context != EGL_NO_CONTEXT)
+    {
+        ANGLE_TRY(ValidateContext(display, context));
+    }
+
+    if (display->isInitialized() && display->isDeviceLost())
+    {
+        return EglContextLost();
+    }
+
+    if (draw != EGL_NO_SURFACE)
+    {
+        ANGLE_TRY(ValidateSurface(display, draw));
+    }
+
+    if (read != EGL_NO_SURFACE)
+    {
+        ANGLE_TRY(ValidateSurface(display, read));
+        ANGLE_TRY(ValidateCompatibleConfigs(display, read->getConfig(), read, context->getConfig(),
+                                            read->getType()));
+    }
+
+    if (draw != read)
+    {
+        UNIMPLEMENTED();  // FIXME
+
+        if (draw)
+        {
+            ANGLE_TRY(ValidateCompatibleConfigs(display, draw->getConfig(), draw,
+                                                context->getConfig(), draw->getType()));
+        }
+    }
+    return NoError();
+}
+
+Error ValidateCompatibleConfigs(const Display *display,
+                                const Config *config1,
+                                const Surface *surface,
+                                const Config *config2,
+                                EGLint surfaceType)
+{
+
+    if (!surface->flexibleSurfaceCompatibilityRequested())
+    {
+        // Config compatibility is defined in section 2.2 of the EGL 1.5 spec
+
+        bool colorBufferCompat = config1->colorBufferType == config2->colorBufferType;
+        if (!colorBufferCompat)
+        {
+            return EglBadMatch() << "Color buffer types are not compatible.";
+        }
+
+        bool colorCompat =
+            config1->redSize == config2->redSize && config1->greenSize == config2->greenSize &&
+            config1->blueSize == config2->blueSize && config1->alphaSize == config2->alphaSize &&
+            config1->luminanceSize == config2->luminanceSize;
+        if (!colorCompat)
+        {
+            return EglBadMatch() << "Color buffer sizes are not compatible.";
+        }
+
+        bool componentTypeCompat = config1->colorComponentType == config2->colorComponentType;
+        if (!componentTypeCompat)
+        {
+            return EglBadMatch() << "Color buffer component types are not compatible.";
+        }
+
+        bool dsCompat = config1->depthSize == config2->depthSize &&
+                        config1->stencilSize == config2->stencilSize;
+        if (!dsCompat)
+        {
+            return EglBadMatch() << "Depth-stencil buffer types are not compatible.";
+        }
+    }
+
+    bool surfaceTypeCompat = (config1->surfaceType & config2->surfaceType & surfaceType) != 0;
+    if (!surfaceTypeCompat)
+    {
+        return EglBadMatch() << "Surface types are not compatible.";
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateImage(const Display *display,
+                          gl::Context *context,
+                          EGLenum target,
+                          EGLClientBuffer buffer,
+                          const AttributeMap &attributes)
+{
+
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+
+    // TODO(geofflang): Complete validation from EGL_KHR_image_base:
+    // If the resource specified by <dpy>, <ctx>, <target>, <buffer> and <attrib_list> is itself an
+    // EGLImage sibling, the error EGL_BAD_ACCESS is generated.
+
+    for (AttributeMap::const_iterator attributeIter = attributes.begin();
+         attributeIter != attributes.end(); attributeIter++)
+    {
+        EGLAttrib attribute = attributeIter->first;
+        EGLAttrib value     = attributeIter->second;
+
+        switch (attribute)
+        {
+            case EGL_IMAGE_PRESERVED:
+                switch (value)
+                {
+                    case EGL_TRUE:
+                    case EGL_FALSE:
+                        break;
+
+                    default:
+                        return EglBadParameter()
+                               << "EGL_IMAGE_PRESERVED must be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+
+            case EGL_GL_TEXTURE_LEVEL:
+                if (!displayExtensions.glTexture2DImage &&
+                    !displayExtensions.glTextureCubemapImage && !displayExtensions.glTexture3DImage)
+                {
+                    return EglBadParameter() << "EGL_GL_TEXTURE_LEVEL cannot be used "
+                                                "without KHR_gl_texture_*_image support.";
+                }
+
+                if (value < 0)
+                {
+                    return EglBadParameter() << "EGL_GL_TEXTURE_LEVEL cannot be negative.";
+                }
+                break;
+
+            case EGL_GL_TEXTURE_ZOFFSET:
+                if (!displayExtensions.glTexture3DImage)
+                {
+                    return EglBadParameter() << "EGL_GL_TEXTURE_ZOFFSET cannot be used "
+                                                "without KHR_gl_texture_3D_image support.";
+                }
+                break;
+
+            default:
+                return EglBadParameter()
+                       << "invalid attribute: 0x" << std::hex << std::uppercase << attribute;
+        }
+    }
+
+    switch (target)
+    {
+        case EGL_GL_TEXTURE_2D:
+        {
+            if (!displayExtensions.glTexture2DImage)
+            {
+                return EglBadParameter() << "KHR_gl_texture_2D_image not supported.";
+            }
+
+            if (buffer == 0)
+            {
+                return EglBadParameter() << "buffer cannot reference a 2D texture with the name 0.";
+            }
+
+            ANGLE_TRY(ValidateContext(display, context));
+            const gl::Texture *texture =
+                context->getTexture(egl_gl::EGLClientBufferToGLObjectHandle(buffer));
+            if (texture == nullptr || texture->getType() != gl::TextureType::_2D)
+            {
+                return EglBadParameter() << "target is not a 2D texture.";
+            }
+
+            if (texture->getBoundSurface() != nullptr)
+            {
+                return EglBadAccess() << "texture has a surface bound to it.";
+            }
+
+            EGLAttrib level = attributes.get(EGL_GL_TEXTURE_LEVEL, 0);
+            if (texture->getWidth(gl::TextureTarget::_2D, static_cast<size_t>(level)) == 0 ||
+                texture->getHeight(gl::TextureTarget::_2D, static_cast<size_t>(level)) == 0)
+            {
+                return EglBadParameter()
+                       << "target 2D texture does not have a valid size at specified level.";
+            }
+
+            ANGLE_TRY(ValidateCreateImageMipLevelCommon(context, texture, level));
+        }
+        break;
+
+        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+        {
+            if (!displayExtensions.glTextureCubemapImage)
+            {
+                return EglBadParameter() << "KHR_gl_texture_cubemap_image not supported.";
+            }
+
+            if (buffer == 0)
+            {
+                return EglBadParameter()
+                       << "buffer cannot reference a cubemap texture with the name 0.";
+            }
+
+            ANGLE_TRY(ValidateContext(display, context));
+            const gl::Texture *texture =
+                context->getTexture(egl_gl::EGLClientBufferToGLObjectHandle(buffer));
+            if (texture == nullptr || texture->getType() != gl::TextureType::CubeMap)
+            {
+                return EglBadParameter() << "target is not a cubemap texture.";
+            }
+
+            if (texture->getBoundSurface() != nullptr)
+            {
+                return EglBadAccess() << "texture has a surface bound to it.";
+            }
+
+            EGLAttrib level               = attributes.get(EGL_GL_TEXTURE_LEVEL, 0);
+            gl::TextureTarget cubeMapFace = egl_gl::EGLCubeMapTargetToCubeMapTarget(target);
+            if (texture->getWidth(cubeMapFace, static_cast<size_t>(level)) == 0 ||
+                texture->getHeight(cubeMapFace, static_cast<size_t>(level)) == 0)
+            {
+                return EglBadParameter() << "target cubemap texture does not have a valid "
+                                            "size at specified level and face.";
+            }
+
+            ANGLE_TRY(ValidateCreateImageMipLevelCommon(context, texture, level));
+
+            if (level == 0 && !texture->isMipmapComplete() &&
+                CubeTextureHasUnspecifiedLevel0Face(texture))
+            {
+                return EglBadParameter() << "if level is zero and the texture is incomplete, "
+                                            "it must have all of its faces specified at level "
+                                            "zero.";
+            }
+        }
+        break;
+
+        case EGL_GL_TEXTURE_3D:
+        {
+            if (!displayExtensions.glTexture3DImage)
+            {
+                return EglBadParameter() << "KHR_gl_texture_3D_image not supported.";
+            }
+
+            if (buffer == 0)
+            {
+                return EglBadParameter() << "buffer cannot reference a 3D texture with the name 0.";
+            }
+
+            ANGLE_TRY(ValidateContext(display, context));
+            const gl::Texture *texture =
+                context->getTexture(egl_gl::EGLClientBufferToGLObjectHandle(buffer));
+            if (texture == nullptr || texture->getType() != gl::TextureType::_3D)
+            {
+                return EglBadParameter() << "target is not a 3D texture.";
+            }
+
+            if (texture->getBoundSurface() != nullptr)
+            {
+                return EglBadAccess() << "texture has a surface bound to it.";
+            }
+
+            EGLAttrib level   = attributes.get(EGL_GL_TEXTURE_LEVEL, 0);
+            EGLAttrib zOffset = attributes.get(EGL_GL_TEXTURE_ZOFFSET, 0);
+            if (texture->getWidth(gl::TextureTarget::_3D, static_cast<size_t>(level)) == 0 ||
+                texture->getHeight(gl::TextureTarget::_3D, static_cast<size_t>(level)) == 0 ||
+                texture->getDepth(gl::TextureTarget::_3D, static_cast<size_t>(level)) == 0)
+            {
+                return EglBadParameter()
+                       << "target 3D texture does not have a valid size at specified level.";
+            }
+
+            if (static_cast<size_t>(zOffset) >=
+                texture->getDepth(gl::TextureTarget::_3D, static_cast<size_t>(level)))
+            {
+                return EglBadParameter() << "target 3D texture does not have enough layers "
+                                            "for the specified Z offset at the specified "
+                                            "level.";
+            }
+
+            ANGLE_TRY(ValidateCreateImageMipLevelCommon(context, texture, level));
+        }
+        break;
+
+        case EGL_GL_RENDERBUFFER:
+        {
+            if (!displayExtensions.glRenderbufferImage)
+            {
+                return EglBadParameter() << "KHR_gl_renderbuffer_image not supported.";
+            }
+
+            if (attributes.contains(EGL_GL_TEXTURE_LEVEL))
+            {
+                return EglBadParameter() << "EGL_GL_TEXTURE_LEVEL cannot be used in "
+                                            "conjunction with a renderbuffer target.";
+            }
+
+            if (buffer == 0)
+            {
+                return EglBadParameter()
+                       << "buffer cannot reference a renderbuffer with the name 0.";
+            }
+
+            ANGLE_TRY(ValidateContext(display, context));
+            const gl::Renderbuffer *renderbuffer =
+                context->getRenderbuffer(egl_gl::EGLClientBufferToGLObjectHandle(buffer));
+            if (renderbuffer == nullptr)
+            {
+                return EglBadParameter() << "target is not a renderbuffer.";
+            }
+
+            if (renderbuffer->getSamples() > 0)
+            {
+                return EglBadParameter() << "target renderbuffer cannot be multisampled.";
+            }
+        }
+        break;
+
+        case EGL_NATIVE_BUFFER_ANDROID:
+        {
+            if (!displayExtensions.imageNativeBuffer)
+            {
+                return EglBadParameter() << "EGL_ANDROID_image_native_buffer not supported.";
+            }
+
+            if (context != nullptr)
+            {
+                return EglBadContext() << "ctx must be EGL_NO_CONTEXT.";
+            }
+
+            ANGLE_TRY(display->validateImageClientBuffer(context, target, buffer, attributes));
+        }
+        break;
+
+        case EGL_D3D11_TEXTURE_ANGLE:
+            if (!displayExtensions.imageD3D11Texture)
+            {
+                return EglBadParameter() << "EGL_ANGLE_image_d3d11_texture not supported.";
+            }
+
+            if (context != nullptr)
+            {
+                return EglBadContext() << "ctx must be EGL_NO_CONTEXT.";
+            }
+
+            ANGLE_TRY(display->validateImageClientBuffer(context, target, buffer, attributes));
+            break;
+
+        default:
+            return EglBadParameter()
+                   << "invalid target: 0x" << std::hex << std::uppercase << target;
+    }
+
+    if (attributes.contains(EGL_GL_TEXTURE_ZOFFSET) && target != EGL_GL_TEXTURE_3D)
+    {
+        return EglBadParameter() << "EGL_GL_TEXTURE_ZOFFSET must be used with a 3D texture target.";
+    }
+
+    return NoError();
+}
+
+Error ValidateDestroyImage(const Display *display, const Image *image)
+{
+    ANGLE_TRY(ValidateImage(display, image));
+
+    return NoError();
+}
+
+Error ValidateCreateImageKHR(const Display *display,
+                             gl::Context *context,
+                             EGLenum target,
+                             EGLClientBuffer buffer,
+                             const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().imageBase && !display->getExtensions().image)
+    {
+        // It is out of spec what happens when calling an extension function when the extension is
+        // not available.
+        // EGL_BAD_DISPLAY seems like a reasonable error.
+        return EglBadDisplay() << "EGL_KHR_image not supported.";
+    }
+
+    return ValidateCreateImage(display, context, target, buffer, attributes);
+}
+
+Error ValidateDestroyImageKHR(const Display *display, const Image *image)
+{
+    ANGLE_TRY(ValidateImage(display, image));
+
+    if (!display->getExtensions().imageBase && !display->getExtensions().image)
+    {
+        // It is out of spec what happens when calling an extension function when the extension is
+        // not available.
+        // EGL_BAD_DISPLAY seems like a reasonable error.
+        return EglBadDisplay();
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateDeviceANGLE(EGLint device_type,
+                                void *native_device,
+                                const EGLAttrib *attrib_list)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+    if (!clientExtensions.deviceCreation)
+    {
+        return EglBadAccess() << "Device creation extension not active";
+    }
+
+    if (attrib_list != nullptr && attrib_list[0] != EGL_NONE)
+    {
+        return EglBadAttribute() << "Invalid attrib_list parameter";
+    }
+
+    switch (device_type)
+    {
+        case EGL_D3D11_DEVICE_ANGLE:
+            if (!clientExtensions.deviceCreationD3D11)
+            {
+                return EglBadAttribute() << "D3D11 device creation extension not active";
+            }
+            break;
+        default:
+            return EglBadAttribute() << "Invalid device_type parameter";
+    }
+
+    return NoError();
+}
+
+Error ValidateReleaseDeviceANGLE(Device *device)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+    if (!clientExtensions.deviceCreation)
+    {
+        return EglBadAccess() << "Device creation extension not active";
+    }
+
+    if (device == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(device))
+    {
+        return EglBadDevice() << "Invalid device parameter";
+    }
+
+    Display *owningDisplay = device->getOwningDisplay();
+    if (owningDisplay != nullptr)
+    {
+        return EglBadDevice() << "Device must have been created using eglCreateDevice";
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateSyncBase(const Display *display,
+                             EGLenum type,
+                             const AttributeMap &attribs,
+                             const Display *currentDisplay,
+                             const gl::Context *currentContext,
+                             bool isExt)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    switch (type)
+    {
+        case EGL_SYNC_FENCE_KHR:
+            if (!attribs.isEmpty())
+            {
+                return EglBadAttribute() << "Invalid attribute";
+            }
+            break;
+
+        case EGL_SYNC_NATIVE_FENCE_ANDROID:
+            if (!display->getExtensions().nativeFenceSyncANDROID)
+            {
+                return EglBadDisplay()
+                       << "EGL_ANDROID_native_fence_sync extension is not available.";
+            }
+
+            for (const auto &attributeIter : attribs)
+            {
+                EGLAttrib attribute = attributeIter.first;
+
+                switch (attribute)
+                {
+                    case EGL_SYNC_NATIVE_FENCE_FD_ANDROID:
+                        break;
+
+                    default:
+                        return EglBadAttribute() << "Invalid attribute";
+                }
+            }
+            break;
+
+        default:
+            if (isExt)
+            {
+                return EglBadAttribute() << "Invalid type parameter";
+            }
+            else
+            {
+                return EglBadParameter() << "Invalid type parameter";
+            }
+    }
+
+    if (display != currentDisplay)
+    {
+        return EglBadMatch() << "CreateSync can only be called on the current display";
+    }
+
+    ANGLE_TRY(ValidateContext(currentDisplay, currentContext));
+
+    if (!currentContext->getExtensions().eglSync)
+    {
+        return EglBadMatch() << "EGL_SYNC_FENCE_KHR cannot be used without "
+                                "GL_OES_EGL_sync support.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetSyncAttribBase(const Display *display, const Sync *sync, EGLint attribute)
+{
+    ANGLE_TRY(ValidateSync(display, sync));
+
+    switch (attribute)
+    {
+        case EGL_SYNC_CONDITION_KHR:
+            switch (sync->getType())
+            {
+                case EGL_SYNC_FENCE_KHR:
+                case EGL_SYNC_NATIVE_FENCE_ANDROID:
+                    break;
+
+                default:
+                    return EglBadAttribute()
+                           << "EGL_SYNC_CONDITION_KHR is not valid for this sync type.";
+            }
+            break;
+
+        // The following attributes are accepted by all types
+        case EGL_SYNC_TYPE_KHR:
+        case EGL_SYNC_STATUS_KHR:
+            break;
+
+        default:
+            return EglBadAttribute() << "Invalid attribute";
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateSyncKHR(const Display *display,
+                            EGLenum type,
+                            const AttributeMap &attribs,
+                            const Display *currentDisplay,
+                            const gl::Context *currentContext)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &extensions = display->getExtensions();
+    if (!extensions.fenceSync)
+    {
+        return EglBadAccess() << "EGL_KHR_fence_sync extension is not available";
+    }
+
+    return ValidateCreateSyncBase(display, type, attribs, currentDisplay, currentContext, true);
+}
+
+Error ValidateCreateSync(const Display *display,
+                         EGLenum type,
+                         const AttributeMap &attribs,
+                         const Display *currentDisplay,
+                         const gl::Context *currentContext)
+{
+    return ValidateCreateSyncBase(display, type, attribs, currentDisplay, currentContext, false);
+}
+
+Error ValidateDestroySync(const Display *display, const Sync *sync)
+{
+    ANGLE_TRY(ValidateSync(display, sync));
+    return NoError();
+}
+
+Error ValidateClientWaitSync(const Display *display,
+                             const Sync *sync,
+                             EGLint flags,
+                             EGLTime timeout)
+{
+    ANGLE_TRY(ValidateSync(display, sync));
+    return NoError();
+}
+
+Error ValidateWaitSync(const Display *display,
+                       const gl::Context *context,
+                       const Sync *sync,
+                       EGLint flags)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &extensions = display->getExtensions();
+    if (!extensions.waitSync)
+    {
+        return EglBadAccess() << "EGL_KHR_wait_sync extension is not available";
+    }
+
+    ANGLE_TRY(ValidateSync(display, sync));
+
+    if (context == nullptr)
+    {
+        return EglBadMatch() << "No context is current.";
+    }
+
+    if (!context->getExtensions().eglSync)
+    {
+        return EglBadMatch() << "Server-side waits cannot be performed without "
+                                "GL_OES_EGL_sync support.";
+    }
+
+    if (flags != 0)
+    {
+        return EglBadParameter() << "flags must be zero";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetSyncAttribKHR(const Display *display,
+                               const Sync *sync,
+                               EGLint attribute,
+                               EGLint *value)
+{
+    if (value == nullptr)
+    {
+        return EglBadParameter() << "Invalid value parameter";
+    }
+    return ValidateGetSyncAttribBase(display, sync, attribute);
+}
+
+Error ValidateGetSyncAttrib(const Display *display,
+                            const Sync *sync,
+                            EGLint attribute,
+                            EGLAttrib *value)
+{
+    if (value == nullptr)
+    {
+        return EglBadParameter() << "Invalid value parameter";
+    }
+    return ValidateGetSyncAttribBase(display, sync, attribute);
+}
+
+Error ValidateCreateStreamKHR(const Display *display, const AttributeMap &attributes)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.stream)
+    {
+        return EglBadAlloc() << "Stream extension not active";
+    }
+
+    for (const auto &attributeIter : attributes)
+    {
+        EGLAttrib attribute = attributeIter.first;
+        EGLAttrib value     = attributeIter.second;
+
+        ANGLE_TRY(ValidateStreamAttribute(attribute, value, displayExtensions));
+    }
+
+    return NoError();
+}
+
+Error ValidateDestroyStreamKHR(const Display *display, const Stream *stream)
+{
+    ANGLE_TRY(ValidateStream(display, stream));
+    return NoError();
+}
+
+Error ValidateStreamAttribKHR(const Display *display,
+                              const Stream *stream,
+                              EGLint attribute,
+                              EGLint value)
+{
+    ANGLE_TRY(ValidateStream(display, stream));
+
+    if (stream->getState() == EGL_STREAM_STATE_DISCONNECTED_KHR)
+    {
+        return EglBadState() << "Bad stream state";
+    }
+
+    return ValidateStreamAttribute(attribute, value, display->getExtensions());
+}
+
+Error ValidateQueryStreamKHR(const Display *display,
+                             const Stream *stream,
+                             EGLenum attribute,
+                             EGLint *value)
+{
+    ANGLE_TRY(ValidateStream(display, stream));
+
+    switch (attribute)
+    {
+        case EGL_STREAM_STATE_KHR:
+        case EGL_CONSUMER_LATENCY_USEC_KHR:
+            break;
+        case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
+            if (!display->getExtensions().streamConsumerGLTexture)
+            {
+                return EglBadAttribute() << "Consumer GLTexture extension not active";
+            }
+            break;
+        default:
+            return EglBadAttribute() << "Invalid attribute";
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryStreamu64KHR(const Display *display,
+                                const Stream *stream,
+                                EGLenum attribute,
+                                EGLuint64KHR *value)
+{
+    ANGLE_TRY(ValidateStream(display, stream));
+
+    switch (attribute)
+    {
+        case EGL_CONSUMER_FRAME_KHR:
+        case EGL_PRODUCER_FRAME_KHR:
+            break;
+        default:
+            return EglBadAttribute() << "Invalid attribute";
+    }
+
+    return NoError();
+}
+
+Error ValidateStreamConsumerGLTextureExternalKHR(const Display *display,
+                                                 gl::Context *context,
+                                                 const Stream *stream)
+{
+    ANGLE_TRY(ValidateContext(display, context));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamConsumerGLTexture)
+    {
+        return EglBadAccess() << "Stream consumer extension not active";
+    }
+
+    if (!context->getExtensions().eglStreamConsumerExternal)
+    {
+        return EglBadAccess() << "EGL stream consumer external GL extension not enabled";
+    }
+
+    if (stream == EGL_NO_STREAM_KHR || !display->isValidStream(stream))
+    {
+        return EglBadStream() << "Invalid stream";
+    }
+
+    if (stream->getState() != EGL_STREAM_STATE_CREATED_KHR)
+    {
+        return EglBadState() << "Invalid stream state";
+    }
+
+    // Lookup the texture and ensure it is correct
+    gl::Texture *texture = context->getState().getTargetTexture(gl::TextureType::External);
+    if (texture == nullptr || texture->getId() == 0)
+    {
+        return EglBadAccess() << "No external texture bound";
+    }
+
+    return NoError();
+}
+
+Error ValidateStreamConsumerAcquireKHR(const Display *display,
+                                       gl::Context *context,
+                                       const Stream *stream)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamConsumerGLTexture)
+    {
+        return EglBadAccess() << "Stream consumer extension not active";
+    }
+
+    if (stream == EGL_NO_STREAM_KHR || !display->isValidStream(stream))
+    {
+        return EglBadStream() << "Invalid stream";
+    }
+
+    if (!context)
+    {
+        return EglBadAccess() << "No GL context current to calling thread.";
+    }
+
+    ANGLE_TRY(ValidateContext(display, context));
+
+    if (!stream->isConsumerBoundToContext(context))
+    {
+        return EglBadAccess() << "Current GL context not associated with stream consumer";
+    }
+
+    if (stream->getConsumerType() != Stream::ConsumerType::GLTextureRGB &&
+        stream->getConsumerType() != Stream::ConsumerType::GLTextureYUV)
+    {
+        return EglBadAccess() << "Invalid stream consumer type";
+    }
+
+    // Note: technically EGL_STREAM_STATE_EMPTY_KHR is a valid state when the timeout is non-zero.
+    // However, the timeout is effectively ignored since it has no useful functionality with the
+    // current producers that are implemented, so we don't allow that state
+    if (stream->getState() != EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR &&
+        stream->getState() != EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR)
+    {
+        return EglBadState() << "Invalid stream state";
+    }
+
+    return NoError();
+}
+
+Error ValidateStreamConsumerReleaseKHR(const Display *display,
+                                       gl::Context *context,
+                                       const Stream *stream)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamConsumerGLTexture)
+    {
+        return EglBadAccess() << "Stream consumer extension not active";
+    }
+
+    if (stream == EGL_NO_STREAM_KHR || !display->isValidStream(stream))
+    {
+        return EglBadStream() << "Invalid stream";
+    }
+
+    if (!context)
+    {
+        return EglBadAccess() << "No GL context current to calling thread.";
+    }
+
+    ANGLE_TRY(ValidateContext(display, context));
+
+    if (!stream->isConsumerBoundToContext(context))
+    {
+        return EglBadAccess() << "Current GL context not associated with stream consumer";
+    }
+
+    if (stream->getConsumerType() != Stream::ConsumerType::GLTextureRGB &&
+        stream->getConsumerType() != Stream::ConsumerType::GLTextureYUV)
+    {
+        return EglBadAccess() << "Invalid stream consumer type";
+    }
+
+    if (stream->getState() != EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR &&
+        stream->getState() != EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR)
+    {
+        return EglBadState() << "Invalid stream state";
+    }
+
+    return NoError();
+}
+
+Error ValidateStreamConsumerGLTextureExternalAttribsNV(const Display *display,
+                                                       gl::Context *context,
+                                                       const Stream *stream,
+                                                       const AttributeMap &attribs)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamConsumerGLTexture)
+    {
+        return EglBadAccess() << "Stream consumer extension not active";
+    }
+
+    ANGLE_TRY(ValidateContext(display, context));
+
+    // Although technically not a requirement in spec, the context needs to be checked for support
+    // for external textures or future logic will cause assertations. This extension is also
+    // effectively useless without external textures.
+    if (!context->getExtensions().eglStreamConsumerExternal)
+    {
+        return EglBadAccess() << "EGL stream consumer external GL extension not enabled";
+    }
+
+    if (stream == EGL_NO_STREAM_KHR || !display->isValidStream(stream))
+    {
+        return EglBadStream() << "Invalid stream";
+    }
+
+    if (stream->getState() != EGL_STREAM_STATE_CREATED_KHR)
+    {
+        return EglBadState() << "Invalid stream state";
+    }
+
+    const gl::Caps &glCaps = context->getCaps();
+
+    EGLAttrib colorBufferType = EGL_RGB_BUFFER;
+    EGLAttrib planeCount      = -1;
+    EGLAttrib plane[3];
+    for (int i = 0; i < 3; i++)
+    {
+        plane[i] = -1;
+    }
+    for (const auto &attributeIter : attribs)
+    {
+        EGLAttrib attribute = attributeIter.first;
+        EGLAttrib value     = attributeIter.second;
+
+        switch (attribute)
+        {
+            case EGL_COLOR_BUFFER_TYPE:
+                if (value != EGL_RGB_BUFFER && value != EGL_YUV_BUFFER_EXT)
+                {
+                    return EglBadParameter() << "Invalid color buffer type";
+                }
+                colorBufferType = value;
+                break;
+            case EGL_YUV_NUMBER_OF_PLANES_EXT:
+                // planeCount = -1 is a tag for the default plane count so the value must be checked
+                // to be positive here to ensure future logic doesn't break on invalid negative
+                // inputs
+                if (value < 0)
+                {
+                    return EglBadMatch() << "Invalid plane count";
+                }
+                planeCount = value;
+                break;
+            default:
+                if (attribute >= EGL_YUV_PLANE0_TEXTURE_UNIT_NV &&
+                    attribute <= EGL_YUV_PLANE2_TEXTURE_UNIT_NV)
+                {
+                    if ((value < 0 ||
+                         value >= static_cast<EGLAttrib>(glCaps.maxCombinedTextureImageUnits)) &&
+                        value != EGL_NONE)
+                    {
+                        return EglBadAccess() << "Invalid texture unit";
+                    }
+                    plane[attribute - EGL_YUV_PLANE0_TEXTURE_UNIT_NV] = value;
+                }
+                else
+                {
+                    return EglBadAttribute() << "Invalid attribute";
+                }
+        }
+    }
+
+    if (colorBufferType == EGL_RGB_BUFFER)
+    {
+        if (planeCount > 0)
+        {
+            return EglBadMatch() << "Plane count must be 0 for RGB buffer";
+        }
+        for (int i = 0; i < 3; i++)
+        {
+            if (plane[i] != -1)
+            {
+                return EglBadMatch() << "Planes cannot be specified";
+            }
+        }
+
+        // Lookup the texture and ensure it is correct
+        gl::Texture *texture = context->getState().getTargetTexture(gl::TextureType::External);
+        if (texture == nullptr || texture->getId() == 0)
+        {
+            return EglBadAccess() << "No external texture bound";
+        }
+    }
+    else
+    {
+        if (planeCount == -1)
+        {
+            planeCount = 2;
+        }
+        if (planeCount < 1 || planeCount > 3)
+        {
+            return EglBadMatch() << "Invalid YUV plane count";
+        }
+        for (EGLAttrib i = planeCount; i < 3; i++)
+        {
+            if (plane[i] != -1)
+            {
+                return EglBadMatch() << "Invalid plane specified";
+            }
+        }
+
+        // Set to ensure no texture is referenced more than once
+        std::set<gl::Texture *> textureSet;
+        for (EGLAttrib i = 0; i < planeCount; i++)
+        {
+            if (plane[i] == -1)
+            {
+                return EglBadMatch() << "Not all planes specified";
+            }
+            if (plane[i] != EGL_NONE)
+            {
+                gl::Texture *texture = context->getState().getSamplerTexture(
+                    static_cast<unsigned int>(plane[i]), gl::TextureType::External);
+                if (texture == nullptr || texture->getId() == 0)
+                {
+                    return EglBadAccess()
+                           << "No external texture bound at one or more specified texture units";
+                }
+                if (textureSet.find(texture) != textureSet.end())
+                {
+                    return EglBadAccess() << "Multiple planes bound to same texture object";
+                }
+                textureSet.insert(texture);
+            }
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateCreateStreamProducerD3DTextureANGLE(const Display *display,
+                                                  const Stream *stream,
+                                                  const AttributeMap &attribs)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamProducerD3DTexture)
+    {
+        return EglBadAccess() << "Stream producer extension not active";
+    }
+
+    ANGLE_TRY(ValidateStream(display, stream));
+
+    if (!attribs.isEmpty())
+    {
+        return EglBadAttribute() << "Invalid attribute";
+    }
+
+    if (stream->getState() != EGL_STREAM_STATE_CONNECTING_KHR)
+    {
+        return EglBadState() << "Stream not in connecting state";
+    }
+
+    switch (stream->getConsumerType())
+    {
+        case Stream::ConsumerType::GLTextureYUV:
+            if (stream->getPlaneCount() != 2)
+            {
+                return EglBadMatch() << "Incompatible stream consumer type";
+            }
+            break;
+
+        case Stream::ConsumerType::GLTextureRGB:
+            if (stream->getPlaneCount() != 1)
+            {
+                return EglBadMatch() << "Incompatible stream consumer type";
+            }
+            break;
+
+        default:
+            return EglBadMatch() << "Incompatible stream consumer type";
+    }
+
+    return NoError();
+}
+
+Error ValidateStreamPostD3DTextureANGLE(const Display *display,
+                                        const Stream *stream,
+                                        void *texture,
+                                        const AttributeMap &attribs)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.streamProducerD3DTexture)
+    {
+        return EglBadAccess() << "Stream producer extension not active";
+    }
+
+    ANGLE_TRY(ValidateStream(display, stream));
+
+    for (auto &attributeIter : attribs)
+    {
+        EGLAttrib attribute = attributeIter.first;
+        EGLAttrib value     = attributeIter.second;
+
+        switch (attribute)
+        {
+            case EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE:
+                if (value < 0)
+                {
+                    return EglBadParameter() << "Invalid subresource index";
+                }
+                break;
+            case EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG:
+                if (value < 0)
+                {
+                    return EglBadParameter() << "Invalid plane offset";
+                }
+                break;
+            default:
+                return EglBadAttribute() << "Invalid attribute";
+        }
+    }
+
+    if (stream->getState() != EGL_STREAM_STATE_EMPTY_KHR &&
+        stream->getState() != EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR &&
+        stream->getState() != EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR)
+    {
+        return EglBadState() << "Stream not fully configured";
+    }
+
+    if (stream->getProducerType() != Stream::ProducerType::D3D11Texture)
+    {
+        return EglBadMatch() << "Incompatible stream producer";
+    }
+
+    if (texture == nullptr)
+    {
+        return EglBadParameter() << "Texture is null";
+    }
+
+    return stream->validateD3D11Texture(texture, attribs);
+}
+
+Error ValidateGetSyncValuesCHROMIUM(const Display *display,
+                                    const Surface *surface,
+                                    const EGLuint64KHR *ust,
+                                    const EGLuint64KHR *msc,
+                                    const EGLuint64KHR *sbc)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    const DisplayExtensions &displayExtensions = display->getExtensions();
+    if (!displayExtensions.getSyncValues)
+    {
+        return EglBadAccess() << "getSyncValues extension not active";
+    }
+
+    if (display->isDeviceLost())
+    {
+        return EglContextLost() << "Context is lost.";
+    }
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        return EglBadSurface() << "getSyncValues surface cannot be EGL_NO_SURFACE";
+    }
+
+    if (!surface->directComposition())
+    {
+        return EglBadSurface() << "getSyncValues surface requires Direct Composition to be enabled";
+    }
+
+    if (ust == nullptr)
+    {
+        return EglBadParameter() << "ust is null";
+    }
+
+    if (msc == nullptr)
+    {
+        return EglBadParameter() << "msc is null";
+    }
+
+    if (sbc == nullptr)
+    {
+        return EglBadParameter() << "sbc is null";
+    }
+
+    return NoError();
+}
+
+Error ValidateDestroySurface(const Display *display,
+                             const Surface *surface,
+                             const EGLSurface eglSurface)
+{
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (eglSurface == EGL_NO_SURFACE)
+    {
+        return EglBadSurface();
+    }
+
+    return NoError();
+}
+
+Error ValidateDestroyContext(const Display *display,
+                             const gl::Context *glCtx,
+                             const EGLContext eglCtx)
+{
+    ANGLE_TRY(ValidateContext(display, glCtx));
+
+    if (eglCtx == EGL_NO_CONTEXT)
+    {
+        return EglBadContext();
+    }
+
+    return NoError();
+}
+
+Error ValidateSwapBuffers(Thread *thread, const Display *display, const Surface *eglSurface)
+{
+    ANGLE_TRY(ValidateSurface(display, eglSurface));
+
+    if (display->isDeviceLost())
+    {
+        return EglContextLost();
+    }
+
+    if (eglSurface == EGL_NO_SURFACE || !thread->getContext() ||
+        thread->getCurrentDrawSurface() != eglSurface)
+    {
+        return EglBadSurface();
+    }
+
+    return NoError();
+}
+
+Error ValidateSwapBuffersWithDamageKHR(const Display *display,
+                                       const Surface *surface,
+                                       EGLint *rects,
+                                       EGLint n_rects)
+{
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (!display->getExtensions().swapBuffersWithDamage)
+    {
+        // It is out of spec what happens when calling an extension function when the extension is
+        // not available. EGL_BAD_DISPLAY seems like a reasonable error.
+        return EglBadDisplay() << "EGL_KHR_swap_buffers_with_damage is not available.";
+    }
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        return EglBadSurface() << "Swap surface cannot be EGL_NO_SURFACE.";
+    }
+
+    if (n_rects < 0)
+    {
+        return EglBadParameter() << "n_rects cannot be negative.";
+    }
+
+    if (n_rects > 0 && rects == nullptr)
+    {
+        return EglBadParameter() << "n_rects cannot be greater than zero when rects is NULL.";
+    }
+
+    // TODO(jmadill): Validate Surface is bound to the thread.
+
+    return NoError();
+}
+
+Error ValidateWaitNative(const Display *display, const EGLint engine)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (engine != EGL_CORE_NATIVE_ENGINE)
+    {
+        return EglBadParameter() << "the 'engine' parameter has an unrecognized value";
+    }
+
+    return NoError();
+}
+
+Error ValidateCopyBuffers(Display *display, const Surface *surface)
+{
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (display->testDeviceLost())
+    {
+        return EglContextLost();
+    }
+
+    return NoError();
+}
+
+// Validate state for eglBindTexImage. If context is non-null then textureObject will be set to
+// surface's texture that will have an image bound to it
+Error ValidateBindTexImage(const Display *display,
+                           const Surface *surface,
+                           const EGLSurface eglSurface,
+                           const EGLint buffer,
+                           const gl::Context *context,
+                           gl::Texture **textureObject)
+{
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (buffer != EGL_BACK_BUFFER)
+    {
+        return EglBadParameter();
+    }
+
+    if (eglSurface == EGL_NO_SURFACE || surface->getType() == EGL_WINDOW_BIT)
+    {
+        return EglBadSurface();
+    }
+
+    if (surface->getBoundTexture())
+    {
+        return EglBadAccess();
+    }
+
+    if (surface->getTextureFormat() == TextureFormat::NoTexture)
+    {
+        return EglBadMatch();
+    }
+
+    if (context)
+    {
+        gl::TextureType type = egl_gl::EGLTextureTargetToTextureType(surface->getTextureTarget());
+        *textureObject       = context->getTextureByType(type);
+        ASSERT(*textureObject != nullptr);
+
+        if ((*textureObject)->getImmutableFormat())
+        {
+            return EglBadMatch();
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateReleaseTexImage(const Display *display,
+                              const Surface *surface,
+                              const EGLSurface eglSurface,
+                              const EGLint buffer)
+{
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (buffer != EGL_BACK_BUFFER)
+    {
+        return EglBadParameter();
+    }
+
+    if (eglSurface == EGL_NO_SURFACE || surface->getType() == EGL_WINDOW_BIT)
+    {
+        return EglBadSurface();
+    }
+
+    if (surface->getTextureFormat() == TextureFormat::NoTexture)
+    {
+        return EglBadMatch();
+    }
+
+    return NoError();
+}
+
+Error ValidateSwapInterval(const Display *display,
+                           const Surface *draw_surface,
+                           const gl::Context *context)
+{
+    ANGLE_TRY(ValidateContext(display, context));
+
+    if (draw_surface == nullptr)
+    {
+        return EglBadSurface();
+    }
+
+    return NoError();
+}
+
+Error ValidateBindAPI(const EGLenum api)
+{
+    switch (api)
+    {
+        case EGL_OPENGL_API:
+        case EGL_OPENVG_API:
+            return EglBadParameter();  // Not supported by this implementation
+        case EGL_OPENGL_ES_API:
+            break;
+        default:
+            return EglBadParameter();
+    }
+
+    return NoError();
+}
+
+Error ValidatePresentationTimeANDROID(const Display *display,
+                                      const Surface *surface,
+                                      EGLnsecsANDROID time)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().presentationTime)
+    {
+        // It is out of spec what happens when calling an extension function when the extension is
+        // not available. EGL_BAD_DISPLAY seems like a reasonable error.
+        return EglBadDisplay() << "EGL_ANDROID_presentation_time is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    return NoError();
+}
+
+Error ValidateSetBlobCacheANDROID(const Display *display,
+                                  EGLSetBlobFuncANDROID set,
+                                  EGLGetBlobFuncANDROID get)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (display->areBlobCacheFuncsSet())
+    {
+        return EglBadParameter()
+               << "Blob cache functions can only be set once in the lifetime of a Display";
+    }
+
+    if (set == nullptr || get == nullptr)
+    {
+        return EglBadParameter() << "Blob cache callbacks cannot be null.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute)
+{
+    ANGLE_TRY(ValidateConfig(display, config));
+    ANGLE_TRY(ValidateConfigAttribute(display, static_cast<EGLAttrib>(attribute)));
+    return NoError();
+}
+
+Error ValidateChooseConfig(const Display *display,
+                           const AttributeMap &attribs,
+                           EGLint configSize,
+                           EGLint *numConfig)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+    ANGLE_TRY(ValidateConfigAttributes(display, attribs));
+
+    if (numConfig == nullptr)
+    {
+        return EglBadParameter() << "num_config cannot be null.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetConfigs(const Display *display, EGLint configSize, EGLint *numConfig)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (numConfig == nullptr)
+    {
+        return EglBadParameter() << "num_config cannot be null.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetPlatformDisplay(EGLenum platform,
+                                 void *native_display,
+                                 const EGLAttrib *attrib_list)
+{
+    const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
+    return ValidateGetPlatformDisplayCommon(platform, native_display, attribMap);
+}
+
+Error ValidateGetPlatformDisplayEXT(EGLenum platform,
+                                    void *native_display,
+                                    const EGLint *attrib_list)
+{
+    const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
+    return ValidateGetPlatformDisplayCommon(platform, native_display, attribMap);
+}
+
+Error ValidateCreatePlatformWindowSurfaceEXT(const Display *display,
+                                             const Config *configuration,
+                                             void *nativeWindow,
+                                             const AttributeMap &attributes)
+{
+    if (!Display::GetClientExtensions().platformBase)
+    {
+        return EglBadAccess() << "EGL_EXT_platform_base not supported";
+    }
+
+    ANGLE_TRY(ValidateConfig(display, configuration));
+
+    return EglBadDisplay() << "ValidateCreatePlatformWindowSurfaceEXT unimplemented.";
+}
+
+Error ValidateCreatePlatformPixmapSurfaceEXT(const Display *display,
+                                             const Config *configuration,
+                                             void *nativePixmap,
+                                             const AttributeMap &attributes)
+{
+    if (!Display::GetClientExtensions().platformBase)
+    {
+        return EglBadAccess() << "EGL_EXT_platform_base not supported";
+    }
+
+    ANGLE_TRY(ValidateConfig(display, configuration));
+
+    return EglBadDisplay() << "ValidateCreatePlatformPixmapSurfaceEXT unimplemented.";
+}
+
+Error ValidateProgramCacheGetAttribANGLE(const Display *display, EGLenum attrib)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().programCacheControl)
+    {
+        return EglBadAccess() << "Extension not supported";
+    }
+
+    switch (attrib)
+    {
+        case EGL_PROGRAM_CACHE_KEY_LENGTH_ANGLE:
+        case EGL_PROGRAM_CACHE_SIZE_ANGLE:
+            break;
+
+        default:
+            return EglBadParameter() << "Invalid program cache attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateProgramCacheQueryANGLE(const Display *display,
+                                     EGLint index,
+                                     void *key,
+                                     EGLint *keysize,
+                                     void *binary,
+                                     EGLint *binarysize)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().programCacheControl)
+    {
+        return EglBadAccess() << "Extension not supported";
+    }
+
+    if (index < 0 || index >= display->programCacheGetAttrib(EGL_PROGRAM_CACHE_SIZE_ANGLE))
+    {
+        return EglBadParameter() << "Program index out of range.";
+    }
+
+    if (keysize == nullptr || binarysize == nullptr)
+    {
+        return EglBadParameter() << "keysize and binarysize must always be valid pointers.";
+    }
+
+    if (binary && *keysize != static_cast<EGLint>(egl::BlobCache::kKeyLength))
+    {
+        return EglBadParameter() << "Invalid program key size.";
+    }
+
+    if ((key == nullptr) != (binary == nullptr))
+    {
+        return EglBadParameter() << "key and binary must both be null or both non-null.";
+    }
+
+    return NoError();
+}
+
+Error ValidateProgramCachePopulateANGLE(const Display *display,
+                                        const void *key,
+                                        EGLint keysize,
+                                        const void *binary,
+                                        EGLint binarysize)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().programCacheControl)
+    {
+        return EglBadAccess() << "Extension not supported";
+    }
+
+    if (keysize != static_cast<EGLint>(egl::BlobCache::kKeyLength))
+    {
+        return EglBadParameter() << "Invalid program key size.";
+    }
+
+    if (key == nullptr || binary == nullptr)
+    {
+        return EglBadParameter() << "null pointer in arguments.";
+    }
+
+    // Upper bound for binarysize is arbitrary.
+    if (binarysize <= 0 || binarysize > egl::kProgramCacheSizeAbsoluteMax)
+    {
+        return EglBadParameter() << "binarysize out of valid range.";
+    }
+
+    return NoError();
+}
+
+Error ValidateProgramCacheResizeANGLE(const Display *display, EGLint limit, EGLenum mode)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().programCacheControl)
+    {
+        return EglBadAccess() << "Extension not supported";
+    }
+
+    if (limit < 0)
+    {
+        return EglBadParameter() << "limit must be non-negative.";
+    }
+
+    switch (mode)
+    {
+        case EGL_PROGRAM_CACHE_RESIZE_ANGLE:
+        case EGL_PROGRAM_CACHE_TRIM_ANGLE:
+            break;
+
+        default:
+            return EglBadParameter() << "Invalid cache resize mode.";
+    }
+
+    return NoError();
+}
+
+Error ValidateSurfaceAttrib(const Display *display,
+                            const Surface *surface,
+                            EGLint attribute,
+                            EGLint value)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        return EglBadSurface() << "Surface cannot be EGL_NO_SURFACE.";
+    }
+
+    switch (attribute)
+    {
+        case EGL_MIPMAP_LEVEL:
+            break;
+
+        case EGL_MULTISAMPLE_RESOLVE:
+            switch (value)
+            {
+                case EGL_MULTISAMPLE_RESOLVE_DEFAULT:
+                    break;
+
+                case EGL_MULTISAMPLE_RESOLVE_BOX:
+                    if ((surface->getConfig()->surfaceType & EGL_MULTISAMPLE_RESOLVE_BOX_BIT) == 0)
+                    {
+                        return EglBadMatch()
+                               << "Surface does not support EGL_MULTISAMPLE_RESOLVE_BOX.";
+                    }
+                    break;
+
+                default:
+                    return EglBadAttribute() << "Invalid multisample resolve type.";
+            }
+            break;
+
+        case EGL_SWAP_BEHAVIOR:
+            switch (value)
+            {
+                case EGL_BUFFER_PRESERVED:
+                    if ((surface->getConfig()->surfaceType & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == 0)
+                    {
+                        return EglBadMatch()
+                               << "Surface does not support EGL_SWAP_BEHAVIOR_PRESERVED.";
+                    }
+                    break;
+
+                case EGL_BUFFER_DESTROYED:
+                    break;
+
+                default:
+                    return EglBadAttribute() << "Invalid swap behaviour.";
+            }
+            break;
+
+        case EGL_WIDTH:
+        case EGL_HEIGHT:
+            if (!display->getExtensions().windowFixedSize)
+            {
+                return EglBadAttribute() << "EGL_WIDTH or EGL_HEIGHT cannot be set without "
+                                            "EGL_ANGLE_window_fixed_size support.";
+            }
+            if (!surface->isFixedSize())
+            {
+                return EglBadMatch() << "EGL_WIDTH or EGL_HEIGHT cannot be set without "
+                                        "EGL_FIXED_SIZE_ANGLE being enabled on the surface.";
+            }
+            break;
+
+        case EGL_TIMESTAMPS_ANDROID:
+            if (!display->getExtensions().getFrameTimestamps)
+            {
+                return EglBadAttribute() << "EGL_TIMESTAMPS_ANDROID cannot be used without "
+                                            "EGL_ANDROID_get_frame_timestamps support.";
+            }
+            switch (value)
+            {
+                case EGL_TRUE:
+                case EGL_FALSE:
+                    break;
+
+                default:
+                    return EglBadAttribute() << "Invalid value.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "Invalid surface attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateQuerySurface(const Display *display,
+                           const Surface *surface,
+                           EGLint attribute,
+                           EGLint *value)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        return EglBadSurface() << "Surface cannot be EGL_NO_SURFACE.";
+    }
+
+    switch (attribute)
+    {
+        case EGL_GL_COLORSPACE:
+        case EGL_VG_ALPHA_FORMAT:
+        case EGL_VG_COLORSPACE:
+        case EGL_CONFIG_ID:
+        case EGL_HEIGHT:
+        case EGL_HORIZONTAL_RESOLUTION:
+        case EGL_LARGEST_PBUFFER:
+        case EGL_MIPMAP_TEXTURE:
+        case EGL_MIPMAP_LEVEL:
+        case EGL_MULTISAMPLE_RESOLVE:
+        case EGL_PIXEL_ASPECT_RATIO:
+        case EGL_RENDER_BUFFER:
+        case EGL_SWAP_BEHAVIOR:
+        case EGL_TEXTURE_FORMAT:
+        case EGL_TEXTURE_TARGET:
+        case EGL_VERTICAL_RESOLUTION:
+        case EGL_WIDTH:
+            break;
+
+        case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
+            if (!display->getExtensions().postSubBuffer)
+            {
+                return EglBadAttribute() << "EGL_POST_SUB_BUFFER_SUPPORTED_NV cannot be used "
+                                            "without EGL_ANGLE_surface_orientation support.";
+            }
+            break;
+
+        case EGL_FIXED_SIZE_ANGLE:
+            if (!display->getExtensions().windowFixedSize)
+            {
+                return EglBadAttribute() << "EGL_FIXED_SIZE_ANGLE cannot be used without "
+                                            "EGL_ANGLE_window_fixed_size support.";
+            }
+            break;
+
+        case EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE:
+            if (!display->getExtensions().flexibleSurfaceCompatibility)
+            {
+                return EglBadAttribute()
+                       << "EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE cannot be "
+                          "used without EGL_ANGLE_flexible_surface_compatibility support.";
+            }
+            break;
+
+        case EGL_SURFACE_ORIENTATION_ANGLE:
+            if (!display->getExtensions().surfaceOrientation)
+            {
+                return EglBadAttribute() << "EGL_SURFACE_ORIENTATION_ANGLE cannot be "
+                                            "queried without "
+                                            "EGL_ANGLE_surface_orientation support.";
+            }
+            break;
+
+        case EGL_DIRECT_COMPOSITION_ANGLE:
+            if (!display->getExtensions().directComposition)
+            {
+                return EglBadAttribute() << "EGL_DIRECT_COMPOSITION_ANGLE cannot be "
+                                            "used without "
+                                            "EGL_ANGLE_direct_composition support.";
+            }
+            break;
+
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            if (!display->getExtensions().robustResourceInitialization)
+            {
+                return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE cannot be "
+                                            "used without EGL_ANGLE_robust_resource_initialization "
+                                            "support.";
+            }
+            break;
+
+        case EGL_TIMESTAMPS_ANDROID:
+            if (!display->getExtensions().getFrameTimestamps)
+            {
+                return EglBadAttribute() << "EGL_TIMESTAMPS_ANDROID cannot be used without "
+                                            "EGL_ANDROID_get_frame_timestamps support.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "Invalid surface attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryContext(const Display *display,
+                           const gl::Context *context,
+                           EGLint attribute,
+                           EGLint *value)
+{
+    ANGLE_TRY(ValidateContext(display, context));
+
+    switch (attribute)
+    {
+        case EGL_CONFIG_ID:
+        case EGL_CONTEXT_CLIENT_TYPE:
+        case EGL_CONTEXT_CLIENT_VERSION:
+        case EGL_RENDER_BUFFER:
+            break;
+
+        case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
+            if (!display->getExtensions().robustResourceInitialization)
+            {
+                return EglBadAttribute() << "EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE cannot be "
+                                            "used without EGL_ANGLE_robust_resource_initialization "
+                                            "support.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "Invalid context attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateDebugMessageControlKHR(EGLDEBUGPROCKHR callback, const AttributeMap &attribs)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+    if (!clientExtensions.debug)
+    {
+        return EglBadAccess() << "EGL_KHR_debug extension is not available.";
+    }
+
+    for (const auto &attrib : attribs)
+    {
+        switch (attrib.first)
+        {
+            case EGL_DEBUG_MSG_CRITICAL_KHR:
+            case EGL_DEBUG_MSG_ERROR_KHR:
+            case EGL_DEBUG_MSG_WARN_KHR:
+            case EGL_DEBUG_MSG_INFO_KHR:
+                if (attrib.second != EGL_TRUE && attrib.second != EGL_FALSE)
+                {
+                    return EglBadAttribute() << "message controls must be EGL_TRUE or EGL_FALSE.";
+                }
+                break;
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryDebugKHR(EGLint attribute, EGLAttrib *value)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+    if (!clientExtensions.debug)
+    {
+        return EglBadAccess() << "EGL_KHR_debug extension is not available.";
+    }
+
+    switch (attribute)
+    {
+        case EGL_DEBUG_MSG_CRITICAL_KHR:
+        case EGL_DEBUG_MSG_ERROR_KHR:
+        case EGL_DEBUG_MSG_WARN_KHR:
+        case EGL_DEBUG_MSG_INFO_KHR:
+        case EGL_DEBUG_CALLBACK_KHR:
+            break;
+
+        default:
+            return EglBadAttribute() << "unknown attribute.";
+    }
+
+    return NoError();
+}
+
+Error ValidateLabelObjectKHR(Thread *thread,
+                             const Display *display,
+                             ObjectType objectType,
+                             EGLObjectKHR object,
+                             EGLLabelKHR label)
+{
+    const ClientExtensions &clientExtensions = Display::GetClientExtensions();
+    if (!clientExtensions.debug)
+    {
+        return EglBadAccess() << "EGL_KHR_debug extension is not available.";
+    }
+
+    LabeledObject *labeledObject = nullptr;
+    ANGLE_TRY(ValidateLabeledObject(thread, display, objectType, object, &labeledObject));
+
+    return NoError();
+}
+
+Error ValidateGetCompositorTimingSupportedANDROID(const Display *display,
+                                                  const Surface *surface,
+                                                  CompositorTiming name)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().getFrameTimestamps)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_get_frame_timestamps extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (!ValidCompositorTimingName(name))
+    {
+        return EglBadParameter() << "invalid timing name.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetCompositorTimingANDROID(const Display *display,
+                                         const Surface *surface,
+                                         EGLint numTimestamps,
+                                         const EGLint *names,
+                                         EGLnsecsANDROID *values)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().getFrameTimestamps)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_get_frame_timestamps extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (names == nullptr && numTimestamps > 0)
+    {
+        return EglBadParameter() << "names is NULL.";
+    }
+
+    if (values == nullptr && numTimestamps > 0)
+    {
+        return EglBadParameter() << "values is NULL.";
+    }
+
+    if (numTimestamps < 0)
+    {
+        return EglBadParameter() << "numTimestamps must be at least 0.";
+    }
+
+    for (EGLint i = 0; i < numTimestamps; i++)
+    {
+        CompositorTiming name = FromEGLenum<CompositorTiming>(names[i]);
+
+        if (!ValidCompositorTimingName(name))
+        {
+            return EglBadParameter() << "invalid compositor timing.";
+        }
+
+        if (!surface->getSupportedCompositorTimings().test(name))
+        {
+            return EglBadParameter() << "compositor timing not supported by surface.";
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateGetNextFrameIdANDROID(const Display *display,
+                                    const Surface *surface,
+                                    EGLuint64KHR *frameId)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().getFrameTimestamps)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_get_frame_timestamps extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (frameId == nullptr)
+    {
+        return EglBadParameter() << "frameId is NULL.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetFrameTimestampSupportedANDROID(const Display *display,
+                                                const Surface *surface,
+                                                Timestamp timestamp)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().getFrameTimestamps)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_get_frame_timestamps extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (!ValidTimestampType(timestamp))
+    {
+        return EglBadParameter() << "invalid timestamp type.";
+    }
+
+    return NoError();
+}
+
+Error ValidateGetFrameTimestampsANDROID(const Display *display,
+                                        const Surface *surface,
+                                        EGLuint64KHR frameId,
+                                        EGLint numTimestamps,
+                                        const EGLint *timestamps,
+                                        EGLnsecsANDROID *values)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().getFrameTimestamps)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_get_frame_timestamps extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    if (!surface->isTimestampsEnabled())
+    {
+        return EglBadSurface() << "timestamp collection is not enabled for this surface.";
+    }
+
+    if (timestamps == nullptr && numTimestamps > 0)
+    {
+        return EglBadParameter() << "timestamps is NULL.";
+    }
+
+    if (values == nullptr && numTimestamps > 0)
+    {
+        return EglBadParameter() << "values is NULL.";
+    }
+
+    if (numTimestamps < 0)
+    {
+        return EglBadParameter() << "numTimestamps must be at least 0.";
+    }
+
+    for (EGLint i = 0; i < numTimestamps; i++)
+    {
+        Timestamp timestamp = FromEGLenum<Timestamp>(timestamps[i]);
+
+        if (!ValidTimestampType(timestamp))
+        {
+            return EglBadParameter() << "invalid timestamp type.";
+        }
+
+        if (!surface->getSupportedTimestamps().test(timestamp))
+        {
+            return EglBadParameter() << "timestamp not supported by surface.";
+        }
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryStringiANGLE(const Display *display, EGLint name, EGLint index)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!Display::GetClientExtensions().featureControlANGLE)
+    {
+        return EglBadDisplay() << "EGL_ANGLE_feature_control extension is not available.";
+    }
+
+    if (index < 0)
+    {
+        return EglBadParameter() << "index is negative.";
+    }
+
+    switch (name)
+    {
+        case EGL_FEATURE_NAME_ANGLE:
+        case EGL_FEATURE_CATEGORY_ANGLE:
+        case EGL_FEATURE_DESCRIPTION_ANGLE:
+        case EGL_FEATURE_BUG_ANGLE:
+        case EGL_FEATURE_STATUS_ANGLE:
+            break;
+        default:
+            return EglBadParameter() << "name is not valid.";
+    }
+
+    if (static_cast<size_t>(index) >= display->getFeatures().size())
+    {
+        return EglBadParameter() << "index is too big.";
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryDisplayAttribBase(const Display *display, const EGLint attribute)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    switch (attribute)
+    {
+        case EGL_DEVICE_EXT:
+            if (!display->getExtensions().deviceQuery)
+            {
+                return EglBadDisplay() << "EGL_EXT_device_query extension is not available.";
+            }
+            break;
+
+        case EGL_FEATURE_COUNT_ANGLE:
+            if (!Display::GetClientExtensions().featureControlANGLE)
+            {
+                return EglBadDisplay() << "EGL_ANGLE_feature_control extension is not available.";
+            }
+            break;
+
+        default:
+            return EglBadAttribute() << "attribute is not valid.";
+    }
+
+    return NoError();
+}
+
+Error ValidateQueryDisplayAttribEXT(const Display *display, const EGLint attribute)
+{
+    ANGLE_TRY(ValidateQueryDisplayAttribBase(display, attribute));
+
+    return NoError();
+}
+
+Error ValidateQueryDisplayAttribANGLE(const Display *display, const EGLint attribute)
+{
+    ANGLE_TRY(ValidateQueryDisplayAttribBase(display, attribute));
+
+    return NoError();
+}
+
+Error ValidateGetNativeClientBufferANDROID(const AHardwareBuffer *buffer)
+{
+    // No extension check is done because no display is passed to eglGetNativeClientBufferANDROID
+    // despite it being a display extension.  No display is needed for the implementation though.
+    if (buffer == nullptr)
+    {
+        return EglBadParameter() << "NULL buffer.";
+    }
+
+    return NoError();
+}
+
+Error ValidateDupNativeFenceFDANDROID(const Display *display, const Sync *sync)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().nativeFenceSyncANDROID)
+    {
+        return EglBadDisplay() << "EGL_ANDROID_native_fence_sync extension is not available.";
+    }
+
+    ANGLE_TRY(ValidateSync(display, sync));
+
+    if (sync->getNativeFenceFD() == EGL_NO_NATIVE_FENCE_FD_ANDROID)
+    {
+        return EglBadParameter() << "EGL_NATIVE_FENCE_FD_ANDROID attribute of sync is "
+                                    "EGL_NO_NATIVE_FENCE_FD_ANDROID";
+    }
+
+    return NoError();
+}
+
+}  // namespace egl