Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

7 files changed, 2372 insertions, 0 deletions

diff --git a/gfx/angle/checkout/include/platform/Feature.h b/gfx/angle/checkout/include/platform/Feature.h
new file mode 100644
index 0000000000..c1de314e80
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/Feature.h
@@ -0,0 +1,196 @@
+//
+// Copyright 2019 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.
+//
+// Feature.h: Definition of structs to hold feature/workaround information.
+//
+
+#ifndef ANGLE_PLATFORM_FEATURE_H_
+#define ANGLE_PLATFORM_FEATURE_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#define ANGLE_FEATURE_CONDITION(set, feature, cond)       \
+    do                                                    \
+    {                                                     \
+        (set)->feature.enabled   = cond;                  \
+        (set)->feature.condition = ANGLE_STRINGIFY(cond); \
+    } while (0)
+
+namespace angle
+{
+
+enum class FeatureCategory
+{
+    FrontendFeatures,
+    FrontendWorkarounds,
+    OpenGLWorkarounds,
+    OpenGLFeatures,
+    D3DWorkarounds,
+    VulkanFeatures,
+    VulkanWorkarounds,
+    VulkanAppWorkarounds,
+    MetalFeatures,
+    MetalWorkarounds,
+};
+
+constexpr char kFeatureCategoryFrontendWorkarounds[]  = "Frontend workarounds";
+constexpr char kFeatureCategoryFrontendFeatures[]     = "Frontend features";
+constexpr char kFeatureCategoryOpenGLWorkarounds[]    = "OpenGL workarounds";
+constexpr char kFeatureCategoryOpenGLFeatures[]       = "OpenGL features";
+constexpr char kFeatureCategoryD3DWorkarounds[]       = "D3D workarounds";
+constexpr char kFeatureCategoryVulkanAppWorkarounds[] = "Vulkan app workarounds";
+constexpr char kFeatureCategoryVulkanWorkarounds[]    = "Vulkan workarounds";
+constexpr char kFeatureCategoryVulkanFeatures[]       = "Vulkan features";
+constexpr char kFeatureCategoryMetalFeatures[]        = "Metal features";
+constexpr char kFeatureCategoryMetalWorkarounds[]     = "Metal workarounds";
+constexpr char kFeatureCategoryUnknown[]              = "Unknown";
+
+inline const char *FeatureCategoryToString(const FeatureCategory &fc)
+{
+    switch (fc)
+    {
+        case FeatureCategory::FrontendFeatures:
+            return kFeatureCategoryFrontendFeatures;
+            break;
+
+        case FeatureCategory::FrontendWorkarounds:
+            return kFeatureCategoryFrontendWorkarounds;
+            break;
+
+        case FeatureCategory::OpenGLWorkarounds:
+            return kFeatureCategoryOpenGLWorkarounds;
+            break;
+
+        case FeatureCategory::OpenGLFeatures:
+            return kFeatureCategoryOpenGLFeatures;
+            break;
+
+        case FeatureCategory::D3DWorkarounds:
+            return kFeatureCategoryD3DWorkarounds;
+            break;
+
+        case FeatureCategory::VulkanFeatures:
+            return kFeatureCategoryVulkanFeatures;
+            break;
+
+        case FeatureCategory::VulkanWorkarounds:
+            return kFeatureCategoryVulkanWorkarounds;
+            break;
+
+        case FeatureCategory::VulkanAppWorkarounds:
+            return kFeatureCategoryVulkanAppWorkarounds;
+            break;
+
+        case FeatureCategory::MetalFeatures:
+            return kFeatureCategoryMetalFeatures;
+            break;
+
+        case FeatureCategory::MetalWorkarounds:
+            return kFeatureCategoryMetalWorkarounds;
+            break;
+
+        default:
+            return kFeatureCategoryUnknown;
+            break;
+    }
+}
+
+constexpr char kFeatureStatusEnabled[]  = "enabled";
+constexpr char kFeatureStatusDisabled[] = "disabled";
+
+inline const char *FeatureStatusToString(const bool &status)
+{
+    if (status)
+    {
+        return kFeatureStatusEnabled;
+    }
+    return kFeatureStatusDisabled;
+}
+
+struct FeatureInfo;
+
+using FeatureMap  = std::map<std::string, FeatureInfo *>;
+using FeatureList = std::vector<const FeatureInfo *>;
+
+struct FeatureInfo
+{
+    FeatureInfo(const FeatureInfo &other);
+    FeatureInfo(const char *name,
+                const FeatureCategory &category,
+                const char *description,
+                FeatureMap *const mapPtr,
+                const char *bug);
+    ~FeatureInfo();
+
+    // The name of the workaround, lowercase, camel_case
+    const char *const name;
+
+    // The category that the workaround belongs to. Eg. "Vulkan workarounds"
+    const FeatureCategory category;
+
+    // A short description to be read by the user.
+    const char *const description;
+
+    // A link to the bug, if any
+    const char *const bug;
+
+    // Whether the workaround is enabled or not. Determined by heuristics like vendor ID and
+    // version, but may be overriden to any value.
+    bool enabled = false;
+
+    // A stringified version of the condition used to set 'enabled'. ie "IsNvidia() && IsApple()"
+    const char *condition;
+};
+
+inline FeatureInfo::FeatureInfo(const FeatureInfo &other) = default;
+inline FeatureInfo::FeatureInfo(const char *name,
+                                const FeatureCategory &category,
+                                const char *description,
+                                FeatureMap *const mapPtr,
+                                const char *bug = "")
+    : name(name),
+      category(category),
+      description(description),
+      bug(bug),
+      enabled(false),
+      condition("")
+{
+    if (mapPtr != nullptr)
+    {
+        (*mapPtr)[std::string(name)] = this;
+    }
+}
+
+inline FeatureInfo::~FeatureInfo() = default;
+
+struct FeatureSetBase
+{
+  public:
+    FeatureSetBase();
+    ~FeatureSetBase();
+
+  private:
+    // Non-copyable
+    FeatureSetBase(const FeatureSetBase &other)            = delete;
+    FeatureSetBase &operator=(const FeatureSetBase &other) = delete;
+
+  protected:
+    FeatureMap members = FeatureMap();
+
+  public:
+    void overrideFeatures(const std::vector<std::string> &featureNames, bool enabled);
+    void populateFeatureList(FeatureList *features) const;
+
+    const FeatureMap &getFeatures() const { return members; }
+};
+
+inline FeatureSetBase::FeatureSetBase()  = default;
+inline FeatureSetBase::~FeatureSetBase() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_WORKAROUND_H_
diff --git a/gfx/angle/checkout/include/platform/FeaturesD3D_autogen.h b/gfx/angle/checkout/include/platform/FeaturesD3D_autogen.h
new file mode 100644
index 0000000000..0df072b497
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/FeaturesD3D_autogen.h
@@ -0,0 +1,198 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_features.py using data from d3d_features.json.
+//
+// Copyright 2022 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.
+//
+// FeaturesD3D_autogen.h: Features and workarounds for D3D driver bugs and other issues.
+
+#ifndef ANGLE_PLATFORM_FEATURESD3D_H_
+#define ANGLE_PLATFORM_FEATURESD3D_H_
+
+#include "platform/Feature.h"
+
+namespace angle
+{
+
+struct FeaturesD3D : FeatureSetBase
+{
+    FeaturesD3D();
+    ~FeaturesD3D();
+
+    FeatureInfo mrtPerfWorkaround = {
+        "mrtPerfWorkaround",
+        FeatureCategory::D3DWorkarounds,
+        "Some drivers have a bug where they ignore null render targets",
+        &members,
+    };
+
+    FeatureInfo setDataFasterThanImageUpload = {
+        "setDataFasterThanImageUpload",
+        FeatureCategory::D3DWorkarounds,
+        "Set data faster than image upload",
+        &members,
+    };
+
+    FeatureInfo setDataFasterThanImageUploadOn128bitFormats = {
+        "setDataFasterThanImageUploadOn128bitFormats",
+        FeatureCategory::D3DWorkarounds,
+        "Set data faster than image upload on 128bit formats",
+        &members,
+    };
+
+    FeatureInfo zeroMaxLodWorkaround = {
+        "zeroMaxLodWorkaround",
+        FeatureCategory::D3DWorkarounds,
+        "Missing an option to disable mipmaps on a mipmapped texture",
+        &members,
+    };
+
+    FeatureInfo useInstancedPointSpriteEmulation = {
+        "useInstancedPointSpriteEmulation",
+        FeatureCategory::D3DWorkarounds,
+        "Some D3D11 renderers do not support geometry shaders for pointsprite emulation",
+        &members,
+    };
+
+    FeatureInfo depthStencilBlitExtraCopy = {
+        "depthStencilBlitExtraCopy", FeatureCategory::D3DWorkarounds,
+        "Bug in some drivers triggers a TDR when using CopySubresourceRegion from a staging "
+        "texture to a depth/stencil",
+        &members, "http://anglebug.com/1452"};
+
+    FeatureInfo expandIntegerPowExpressions = {
+        "expandIntegerPowExpressions",
+        FeatureCategory::D3DWorkarounds,
+        "The HLSL optimizer has a bug with optimizing 'pow' in certain integer-valued expressions",
+        &members,
+    };
+
+    FeatureInfo flushAfterEndingTransformFeedback = {
+        "flushAfterEndingTransformFeedback",
+        FeatureCategory::D3DWorkarounds,
+        "Some drivers sometimes write out-of-order results to StreamOut buffers when transform "
+        "feedback is used to repeatedly write to the same buffer positions",
+        &members,
+    };
+
+    FeatureInfo getDimensionsIgnoresBaseLevel = {
+        "getDimensionsIgnoresBaseLevel",
+        FeatureCategory::D3DWorkarounds,
+        "Some drivers do not take into account the base level of the "
+        "texture in the results of the HLSL GetDimensions builtin",
+        &members,
+    };
+
+    FeatureInfo preAddTexelFetchOffsets = {
+        "preAddTexelFetchOffsets",
+        FeatureCategory::D3DWorkarounds,
+        "HLSL's function texture.Load returns 0 when the parameter Location is negative, even if "
+        "the sum of Offset and Location is in range",
+        &members,
+    };
+
+    FeatureInfo emulateTinyStencilTextures = {
+        "emulateTinyStencilTextures",
+        FeatureCategory::D3DWorkarounds,
+        "1x1 and 2x2 mips of depth/stencil textures aren't sampled correctly",
+        &members,
+    };
+
+    FeatureInfo disableB5G6R5Support = {
+        "disableB5G6R5Support",
+        FeatureCategory::D3DWorkarounds,
+        "Textures with the format "
+        "DXGI_FORMAT_B5G6R5_UNORM have incorrect data",
+        &members,
+    };
+
+    FeatureInfo rewriteUnaryMinusOperator = {
+        "rewriteUnaryMinusOperator",
+        FeatureCategory::D3DWorkarounds,
+        "Evaluating unary minus operator on integer may get wrong answer in vertex shaders",
+        &members,
+    };
+
+    FeatureInfo emulateIsnanFloat = {"emulateIsnanFloat", FeatureCategory::D3DWorkarounds,
+                                     "Using isnan() on highp float will get wrong answer", &members,
+                                     "https://crbug.com/650547"};
+
+    FeatureInfo callClearTwice = {"callClearTwice", FeatureCategory::D3DWorkarounds,
+                                  "Using clear() may not take effect", &members,
+                                  "https://crbug.com/655534"};
+
+    FeatureInfo emulateClearViewAfterDualSourceBlending = {
+        "emulateClearViewAfterDualSourceBlending", FeatureCategory::D3DWorkarounds,
+        "On Sandybridge, calling ClearView after using dual source blending causes hardware to "
+        "hang",
+        &members, "https://bugzilla.mozilla.org/show_bug.cgi?id=1633628"};
+
+    FeatureInfo scissoredClearArtifacts = {
+        "scissoredClearArtifacts", FeatureCategory::D3DWorkarounds,
+        "On Skylake, calling ClearView with a scissor rect that is not a multiple of 8x4 pixels "
+        "causes corruption of pixels in the 8x4 pixel tiles along the edge which resembles a "
+        "square wave",
+        &members, "https://bugzilla.mozilla.org/show_bug.cgi?id=1817240"};
+
+    FeatureInfo useSystemMemoryForConstantBuffers = {
+        "useSystemMemoryForConstantBuffers", FeatureCategory::D3DWorkarounds,
+        "Copying from staging storage to constant buffer "
+        "storage does not work",
+        &members, "https://crbug.com/593024"};
+
+    FeatureInfo selectViewInGeometryShader = {
+        "selectViewInGeometryShader",
+        FeatureCategory::D3DWorkarounds,
+        "The viewport or render target slice will be selected in the geometry shader stage for "
+        "the ANGLE_multiview extension",
+        &members,
+    };
+
+    FeatureInfo addMockTextureNoRenderTarget = {
+        "addMockTextureNoRenderTarget", FeatureCategory::D3DWorkarounds,
+        "On some drivers when rendering with no render target, two bugs lead to incorrect behavior",
+        &members, "http://anglebug.com/2152"};
+
+    FeatureInfo skipVSConstantRegisterZero = {
+        "skipVSConstantRegisterZero",
+        FeatureCategory::D3DWorkarounds,
+        "In specific cases the driver doesn't handle constant register zero correctly",
+        &members,
+    };
+
+    FeatureInfo forceAtomicValueResolution = {
+        "forceAtomicValueResolution", FeatureCategory::D3DWorkarounds,
+        "On some drivers the return value from RWByteAddressBuffer.InterlockedAdd does not resolve "
+        "when used in the .yzw components of a RWByteAddressBuffer.Store operation",
+        &members, "http://anglebug.com/3246"};
+
+    FeatureInfo allowClearForRobustResourceInit = {
+        "allowClearForRobustResourceInit", FeatureCategory::D3DWorkarounds,
+        "Some drivers corrupt texture data when clearing for robust resource initialization.",
+        &members, "http://crbug.com/941620"};
+
+    FeatureInfo allowTranslateUniformBlockToStructuredBuffer = {
+        "allowTranslateUniformBlockToStructuredBuffer", FeatureCategory::D3DWorkarounds,
+        "There is a slow fxc compile performance issue with dynamic uniform indexing if "
+        "translating a uniform block with a large array member to cbuffer.",
+        &members, "http://anglebug.com/3682"};
+
+    FeatureInfo allowES3OnFL100 = {
+        "allowES3OnFL100",
+        FeatureCategory::D3DWorkarounds,
+        "Allow ES3 on 10.0 devices",
+        &members,
+    };
+
+    FeatureInfo disableRasterizerOrderViews = {
+        "disableRasterizerOrderViews", FeatureCategory::D3DWorkarounds, "Disable ROVs for testing",
+        &members, "http://anglebug.com/7279"};
+};
+
+inline FeaturesD3D::FeaturesD3D()  = default;
+inline FeaturesD3D::~FeaturesD3D() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_FEATURESD3D_H_
diff --git a/gfx/angle/checkout/include/platform/FeaturesGL_autogen.h b/gfx/angle/checkout/include/platform/FeaturesGL_autogen.h
new file mode 100644
index 0000000000..5376f3400a
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/FeaturesGL_autogen.h
@@ -0,0 +1,501 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_features.py using data from gl_features.json.
+//
+// Copyright 2022 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.
+//
+// FeaturesGL_autogen.h: angle::Features and workarounds for GL driver bugs and other issues.
+
+#ifndef ANGLE_PLATFORM_FEATURESGL_H_
+#define ANGLE_PLATFORM_FEATURESGL_H_
+
+#include "platform/Feature.h"
+
+namespace angle
+{
+
+struct FeaturesGL : FeatureSetBase
+{
+    FeaturesGL();
+    ~FeaturesGL();
+
+    FeatureInfo avoid1BitAlphaTextureFormats = {
+        "avoid1BitAlphaTextureFormats",
+        FeatureCategory::OpenGLWorkarounds,
+        "Issue with 1-bit alpha framebuffer formats",
+        &members,
+    };
+
+    FeatureInfo RGBA4IsNotSupportedForColorRendering = {
+        "RGBA4IsNotSupportedForColorRendering",
+        FeatureCategory::OpenGLWorkarounds,
+        "GL_RGBA4 is not color renderable",
+        &members,
+    };
+
+    FeatureInfo allowETCFormats = {
+        "allowETCFormats",
+        FeatureCategory::OpenGLWorkarounds,
+        "Enable ETC2/EAC on desktop OpenGL",
+        &members,
+    };
+
+    FeatureInfo allowAstcFormats = {
+        "allowAstcFormats",
+        FeatureCategory::OpenGLWorkarounds,
+        "Enable ASTC on desktop OpenGL",
+        &members,
+    };
+
+    FeatureInfo doesSRGBClearsOnLinearFramebufferAttachments = {
+        "doesSRGBClearsOnLinearFramebufferAttachments",
+        FeatureCategory::OpenGLWorkarounds,
+        "Issue clearing framebuffers with linear attachments when GL_FRAMEBUFFER_SRGB is enabled",
+        &members,
+    };
+
+    FeatureInfo doWhileGLSLCausesGPUHang = {
+        "doWhileGLSLCausesGPUHang", FeatureCategory::OpenGLWorkarounds,
+        "Some GLSL constructs involving do-while loops cause GPU hangs", &members,
+        "http://crbug.com/644669"};
+
+    FeatureInfo vertexIDDoesNotIncludeBaseVertex = {
+        "vertexIDDoesNotIncludeBaseVertex",
+        FeatureCategory::OpenGLWorkarounds,
+        "gl_VertexID in GLSL vertex shader doesn't include base vertex value",
+        &members,
+    };
+
+    FeatureInfo finishDoesNotCauseQueriesToBeAvailable = {
+        "finishDoesNotCauseQueriesToBeAvailable",
+        FeatureCategory::OpenGLWorkarounds,
+        "glFinish doesn't cause all queries to report available result",
+        &members,
+    };
+
+    FeatureInfo alwaysCallUseProgramAfterLink = {
+        "alwaysCallUseProgramAfterLink", FeatureCategory::OpenGLWorkarounds,
+        "Always call useProgram after a successful link to avoid a driver bug", &members,
+        "http://crbug.com/110263"};
+
+    FeatureInfo unpackOverlappingRowsSeparatelyUnpackBuffer = {
+        "unpackOverlappingRowsSeparatelyUnpackBuffer",
+        FeatureCategory::OpenGLWorkarounds,
+        "In the case of unpacking from a pixel unpack buffer, unpack overlapping rows row by row",
+        &members,
+    };
+
+    FeatureInfo packOverlappingRowsSeparatelyPackBuffer = {
+        "packOverlappingRowsSeparatelyPackBuffer",
+        FeatureCategory::OpenGLWorkarounds,
+        "In the case of packing to a pixel pack buffer, pack overlapping rows row by row",
+        &members,
+    };
+
+    FeatureInfo initializeCurrentVertexAttributes = {
+        "initializeCurrentVertexAttributes",
+        FeatureCategory::OpenGLWorkarounds,
+        "During initialization, assign the current vertex attributes to the spec-mandated defaults",
+        &members,
+    };
+
+    FeatureInfo emulateAbsIntFunction = {"emulateAbsIntFunction",
+                                         FeatureCategory::OpenGLWorkarounds,
+                                         "abs(i) where i is an integer returns unexpected result",
+                                         &members, "http://crbug.com/642227"};
+
+    FeatureInfo addAndTrueToLoopCondition = {
+        "addAndTrueToLoopCondition",
+        FeatureCategory::OpenGLWorkarounds,
+        "Calculation of loop conditions in for and while loop has bug",
+        &members,
+    };
+
+    FeatureInfo unpackLastRowSeparatelyForPaddingInclusion = {
+        "unpackLastRowSeparatelyForPaddingInclusion", FeatureCategory::OpenGLWorkarounds,
+        "When uploading textures from an unpack buffer, some drivers count an extra row padding",
+        &members, "http://anglebug.com/1512"};
+
+    FeatureInfo packLastRowSeparatelyForPaddingInclusion = {
+        "packLastRowSeparatelyForPaddingInclusion", FeatureCategory::OpenGLWorkarounds,
+        "When uploading textures from an pack buffer, some drivers count an extra row padding",
+        &members, "http://anglebug.com/1512"};
+
+    FeatureInfo emulateIsnanFloat = {"emulateIsnanFloat", FeatureCategory::OpenGLWorkarounds,
+                                     "Using isnan() on highp float will get wrong answer", &members,
+                                     "http://crbug.com/650547"};
+
+    FeatureInfo useUnusedBlocksWithStandardOrSharedLayout = {
+        "useUnusedBlocksWithStandardOrSharedLayout",
+        FeatureCategory::OpenGLWorkarounds,
+        "Unused std140 or shared uniform blocks will be treated as inactive",
+        &members,
+    };
+
+    FeatureInfo removeInvariantAndCentroidForESSL3 = {
+        "removeInvariantAndCentroidForESSL3",
+        FeatureCategory::OpenGLWorkarounds,
+        "Fix spec difference between GLSL 4.1 or lower and ESSL3",
+        &members,
+    };
+
+    FeatureInfo rewriteFloatUnaryMinusOperator = {
+        "rewriteFloatUnaryMinusOperator", FeatureCategory::OpenGLWorkarounds,
+        "Using '-<float>' will get wrong answer", &members, "http://crbug.com/308366"};
+
+    FeatureInfo emulateAtan2Float = {"emulateAtan2Float", FeatureCategory::OpenGLWorkarounds,
+                                     "atan(y, x) may return a wrong answer", &members,
+                                     "http://crbug.com/672380"};
+
+    FeatureInfo reapplyUBOBindingsAfterUsingBinaryProgram = {
+        "reapplyUBOBindingsAfterUsingBinaryProgram", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers forget about UBO bindings when using program binaries", &members,
+        "http://anglebug.com/1637"};
+
+    FeatureInfo emulateMaxVertexAttribStride = {
+        "emulateMaxVertexAttribStride", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers return 0 when MAX_VERTEX_ATTRIB_STRIED queried", &members,
+        "http://anglebug.com/1936"};
+
+    FeatureInfo dontInitializeUninitializedLocals = {
+        "dontInitializeUninitializedLocals", FeatureCategory::OpenGLWorkarounds,
+        "Initializing uninitialized locals caused odd behavior in a few WebGL 2 tests", &members,
+        "http://anglebug.com/2046"};
+
+    FeatureInfo clampPointSize = {
+        "clampPointSize",
+        FeatureCategory::OpenGLWorkarounds,
+        "The point size range reported from the API is inconsistent with the actual behavior",
+        &members,
+    };
+
+    FeatureInfo dontUseLoopsToInitializeVariables = {
+        "dontUseLoopsToInitializeVariables", FeatureCategory::OpenGLWorkarounds,
+        "For loops used to initialize variables hit native GLSL compiler bugs", &members,
+        "http://crbug.com/809422"};
+
+    FeatureInfo clampFragDepth = {
+        "clampFragDepth",
+        FeatureCategory::OpenGLWorkarounds,
+        "gl_FragDepth is not clamped correctly when rendering to a floating point depth buffer",
+        &members,
+    };
+
+    FeatureInfo rewriteRepeatedAssignToSwizzled = {
+        "rewriteRepeatedAssignToSwizzled",
+        FeatureCategory::OpenGLWorkarounds,
+        "Repeated assignment to swizzled values inside a "
+        "GLSL user-defined function have incorrect results",
+        &members,
+    };
+
+    FeatureInfo disableBlendFuncExtended = {
+        "disableBlendFuncExtended", FeatureCategory::OpenGLWorkarounds,
+        "ARB_blend_func_extended does not pass the tests", &members, "http://anglebug.com/1085"};
+
+    FeatureInfo unsizedSRGBReadPixelsDoesntTransform = {
+        "unsizedSRGBReadPixelsDoesntTransform", FeatureCategory::OpenGLWorkarounds,
+        "Drivers returning raw sRGB values instead of linearized values when calling glReadPixels "
+        "on unsized sRGB texture formats",
+        &members, "http://crbug.com/550292 http://crbug.com/565179"};
+
+    FeatureInfo queryCounterBitsGeneratesErrors = {
+        "queryCounterBitsGeneratesErrors", FeatureCategory::OpenGLWorkarounds,
+        "Drivers generate errors when querying the number of bits in timer queries", &members,
+        "http://anglebug.com/3027"};
+
+    FeatureInfo dontRelinkProgramsInParallel = {
+        "dontRelinkProgramsInParallel", FeatureCategory::OpenGLWorkarounds,
+        "Relinking a program in parallel is buggy", &members, "http://anglebug.com/3045"};
+
+    FeatureInfo disableWorkerContexts = {"disableWorkerContexts",
+                                         FeatureCategory::OpenGLWorkarounds,
+                                         "Some tests have been seen to fail using worker contexts",
+                                         &members, "http://crbug.com/849576"};
+
+    FeatureInfo limitWebglMaxTextureSizeTo4096 = {
+        "limitWebglMaxTextureSizeTo4096", FeatureCategory::OpenGLWorkarounds,
+        "Limit webgl max texture size to 4096 to avoid frequent "
+        "out-of-memory errors",
+        &members, "http://crbug.com/927470"};
+
+    FeatureInfo limitMaxMSAASamplesTo4 = {
+        "limitMaxMSAASamplesTo4", FeatureCategory::OpenGLWorkarounds,
+        "Various rendering bugs have been observed when using higher MSAA counts", &members,
+        "http://crbug.com/797243"};
+
+    FeatureInfo allowClearForRobustResourceInit = {
+        "allowClearForRobustResourceInit", FeatureCategory::OpenGLWorkarounds,
+        "Using glClear for robust resource initialization is buggy on some drivers and leads to "
+        "texture corruption. Default to data uploads except on MacOS where it is very slow.",
+        &members, "https://crbug.com/848952 http://crbug.com/883276"};
+
+    FeatureInfo clampArrayAccess = {"clampArrayAccess", FeatureCategory::OpenGLWorkarounds,
+                                    "Clamp uniform array access to avoid reading invalid memory.",
+                                    &members, "http://anglebug.com/2978"};
+
+    FeatureInfo resetTexImage2DBaseLevel = {
+        "resetTexImage2DBaseLevel", FeatureCategory::OpenGLWorkarounds,
+        "Reset texture base level before calling glTexImage2D to "
+        "work around pixel comparison failure.",
+        &members, "https://crbug.com/705865"};
+
+    FeatureInfo clearToZeroOrOneBroken = {
+        "clearToZeroOrOneBroken", FeatureCategory::OpenGLWorkarounds,
+        "Clears when the clear color is all zeros or ones do not work.", &members,
+        "https://crbug.com/710443"};
+
+    FeatureInfo limitMax3dArrayTextureSizeTo1024 = {
+        "limitMax3dArrayTextureSizeTo1024", FeatureCategory::OpenGLWorkarounds,
+        "Limit max 3d texture size and max array texture layers to 1024 to avoid system hang",
+        &members, "http://crbug.com/927470"};
+
+    FeatureInfo adjustSrcDstRegionForBlitFramebuffer = {
+        "adjustSrcDstRegionForBlitFramebuffer", FeatureCategory::OpenGLWorkarounds,
+        "Many platforms have issues with blitFramebuffer when the parameters are large.", &members,
+        "http://crbug.com/830046"};
+
+    FeatureInfo clipSrcRegionForBlitFramebuffer = {
+        "clipSrcRegionForBlitFramebuffer", FeatureCategory::OpenGLWorkarounds,
+        "Issues with blitFramebuffer when the parameters don't match the framebuffer size.",
+        &members, "http://crbug.com/830046"};
+
+    FeatureInfo RGBDXT1TexturesSampleZeroAlpha = {
+        "RGBDXT1TexturesSampleZeroAlpha", FeatureCategory::OpenGLWorkarounds,
+        "Sampling BLACK texels from RGB DXT1 textures returns transparent black on Mac.", &members,
+        "http://anglebug.com/3729"};
+
+    FeatureInfo unfoldShortCircuits = {
+        "unfoldShortCircuits", FeatureCategory::OpenGLWorkarounds,
+        "Mac incorrectly executes both sides of && and || expressions when they should "
+        "short-circuit.",
+        &members, "http://anglebug.com/482"};
+
+    FeatureInfo emulatePrimitiveRestartFixedIndex = {
+        "emulatePrimitiveRestartFixedIndex", FeatureCategory::OpenGLWorkarounds,
+        "When GL_PRIMITIVE_RESTART_FIXED_INDEX is not available, emulate it with "
+        "GL_PRIMITIVE_RESTART and glPrimitiveRestartIndex.",
+        &members, "http://anglebug.com/3997"};
+
+    FeatureInfo setPrimitiveRestartFixedIndexForDrawArrays = {
+        "setPrimitiveRestartFixedIndexForDrawArrays", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers discard vertex data in DrawArrays calls when the fixed primitive restart "
+        "index is within the number of primitives being drawn.",
+        &members, "http://anglebug.com/3997"};
+
+    FeatureInfo removeDynamicIndexingOfSwizzledVector = {
+        "removeDynamicIndexingOfSwizzledVector", FeatureCategory::OpenGLWorkarounds,
+        "Dynamic indexing of swizzled l-values doesn't work correctly on various platforms.",
+        &members, "http://crbug.com/709351"};
+
+    FeatureInfo preAddTexelFetchOffsets = {
+        "preAddTexelFetchOffsets", FeatureCategory::OpenGLWorkarounds,
+        "Intel Mac drivers mistakenly consider the parameter position of nagative vaule as invalid "
+        "even if the sum of position and offset is in range, so we need to add workarounds by "
+        "rewriting texelFetchOffset(sampler, position, lod, offset) into texelFetch(sampler, "
+        "position + offset, lod).",
+        &members, "http://crbug.com/642605"};
+
+    FeatureInfo regenerateStructNames = {
+        "regenerateStructNames", FeatureCategory::OpenGLWorkarounds,
+        "All Mac drivers do not handle struct scopes correctly. This workaround overwrites a struct"
+        "name with a unique prefix.",
+        &members, "http://crbug.com/403957"};
+
+    FeatureInfo readPixelsUsingImplementationColorReadFormatForNorm16 = {
+        "readPixelsUsingImplementationColorReadFormatForNorm16", FeatureCategory::OpenGLWorkarounds,
+        "Quite some OpenGL ES drivers don't implement readPixels for RGBA/UNSIGNED_SHORT from "
+        "EXT_texture_norm16 correctly",
+        &members, "http://anglebug.com/4214"};
+
+    FeatureInfo flushBeforeDeleteTextureIfCopiedTo = {
+        "flushBeforeDeleteTextureIfCopiedTo", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers track CopyTex{Sub}Image texture dependencies incorrectly. Flush"
+        " before glDeleteTextures in this case",
+        &members, "http://anglebug.com/4267"};
+
+    FeatureInfo rewriteRowMajorMatrices = {
+        "rewriteRowMajorMatrices", FeatureCategory::OpenGLWorkarounds,
+        "Rewrite row major matrices in shaders as column major as a driver bug workaround",
+        &members, "http://anglebug.com/2273"};
+
+    FeatureInfo disableDrawBuffersIndexed = {
+        "disableDrawBuffersIndexed",
+        FeatureCategory::OpenGLWorkarounds,
+        "Disable OES_draw_buffers_indexed extension.",
+        &members,
+    };
+
+    FeatureInfo disableSemaphoreFd = {"disableSemaphoreFd", FeatureCategory::OpenGLWorkarounds,
+                                      "Disable GL_EXT_semaphore_fd extension", &members,
+                                      "https://crbug.com/1046462"};
+
+    FeatureInfo disableTimestampQueries = {
+        "disableTimestampQueries", FeatureCategory::OpenGLWorkarounds,
+        "Disable GL_EXT_disjoint_timer_query extension", &members, "https://crbug.com/811661"};
+
+    FeatureInfo decodeEncodeSRGBForGenerateMipmap = {
+        "decodeEncodeSRGBForGenerateMipmap", FeatureCategory::OpenGLWorkarounds,
+        "Decode and encode before generateMipmap for srgb format textures.", &members,
+        "http://anglebug.com/4646"};
+
+    FeatureInfo emulateCopyTexImage2D = {
+        "emulateCopyTexImage2D",
+        FeatureCategory::OpenGLWorkarounds,
+        "Replace CopyTexImage2D with TexImage2D + CopyTexSubImage2D.",
+        &members,
+    };
+
+    FeatureInfo emulateCopyTexImage2DFromRenderbuffers = {
+        "emulateCopyTexImage2DFromRenderbuffers", FeatureCategory::OpenGLWorkarounds,
+        "CopyTexImage2D spuriously returns errors on iOS when copying from renderbuffers.",
+        &members, "https://anglebug.com/4674"};
+
+    FeatureInfo disableGPUSwitchingSupport = {
+        "disableGPUSwitchingSupport", FeatureCategory::OpenGLWorkarounds,
+        "Disable GPU switching support (use only the low-power GPU) on older MacBook Pros.",
+        &members, "https://crbug.com/1091824"};
+
+    FeatureInfo disableNativeParallelCompile = {
+        "disableNativeParallelCompile", FeatureCategory::OpenGLWorkarounds,
+        "Do not use native KHR_parallel_shader_compile even when available.", &members,
+        "http://crbug.com/1094869"};
+
+    FeatureInfo emulatePackSkipRowsAndPackSkipPixels = {
+        "emulatePackSkipRowsAndPackSkipPixels", FeatureCategory::OpenGLWorkarounds,
+        "GL_PACK_SKIP_ROWS and GL_PACK_SKIP_PIXELS are ignored in Apple's OpenGL driver.", &members,
+        "https://anglebug.com/4849"};
+
+    FeatureInfo clampMscRate = {
+        "clampMscRate", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers return bogus values for GetMscRate, so we clamp it to 30Hz", &members,
+        "https://crbug.com/1042393"};
+
+    FeatureInfo bindTransformFeedbackBufferBeforeBindBufferRange = {
+        "bindTransformFeedbackBufferBeforeBindBufferRange", FeatureCategory::OpenGLWorkarounds,
+        "Bind transform feedback buffers to the generic binding point before calling "
+        "glBindBufferBase or glBindBufferRange.",
+        &members, "https://anglebug.com/5140"};
+
+    FeatureInfo disableSyncControlSupport = {
+        "disableSyncControlSupport", FeatureCategory::OpenGLWorkarounds,
+        "Speculative fix for issues on Linux/Wayland where exposing GLX_OML_sync_control renders "
+        "Chrome unusable",
+        &members, "https://crbug.com/1137851"};
+
+    FeatureInfo keepBufferShadowCopy = {
+        "keepBufferShadowCopy",
+        FeatureCategory::OpenGLWorkarounds,
+        "Maintain a shadow copy of buffer data when the GL API does not permit reading data back.",
+        &members,
+    };
+
+    FeatureInfo setZeroLevelBeforeGenerateMipmap = {
+        "setZeroLevelBeforeGenerateMipmap",
+        FeatureCategory::OpenGLWorkarounds,
+        "glGenerateMipmap fails if the zero texture level is not set on some Mac drivers.",
+        &members,
+    };
+
+    FeatureInfo promotePackedFormatsTo8BitPerChannel = {
+        "promotePackedFormatsTo8BitPerChannel", FeatureCategory::OpenGLWorkarounds,
+        "Packed color formats are buggy on Macs with AMD GPUs", &members,
+        "http://anglebug.com/5469"};
+
+    FeatureInfo initFragmentOutputVariables = {
+        "initFragmentOutputVariables", FeatureCategory::OpenGLWorkarounds,
+        "No init gl_FragColor causes context lost", &members, "http://crbug.com/1171371"};
+
+    FeatureInfo shiftInstancedArrayDataWithOffset = {
+        "shiftInstancedArrayDataWithOffset", FeatureCategory::OpenGLWorkarounds,
+        "glDrawArraysInstanced is buggy on certain new Mac Intel GPUs", &members,
+        "http://crbug.com/1144207"};
+
+    FeatureInfo syncVertexArraysToDefault = {
+        "syncVertexArraysToDefault", FeatureCategory::OpenGLWorkarounds,
+        "Only use the default VAO because of missing support or driver bugs", &members,
+        "http://anglebug.com/5577"};
+
+    FeatureInfo sanitizeAMDGPURendererString = {
+        "sanitizeAMDGPURendererString", FeatureCategory::OpenGLWorkarounds,
+        "Strip precise kernel and DRM version information from amdgpu renderer strings.", &members,
+        "http://crbug.com/1181193"};
+
+    FeatureInfo unbindFBOBeforeSwitchingContext = {
+        "unbindFBOBeforeSwitchingContext", FeatureCategory::OpenGLWorkarounds,
+        "Imagination GL drivers are buggy with context switching.", &members,
+        "http://crbug.com/1181193"};
+
+    FeatureInfo flushOnFramebufferChange = {"flushOnFramebufferChange",
+                                            FeatureCategory::OpenGLWorkarounds,
+                                            "Switching framebuffers without a flush can lead to "
+                                            "crashes on Intel 9th Generation GPU Macs.",
+                                            &members, "http://crbug.com/1181068"};
+
+    FeatureInfo disableMultisampledRenderToTexture = {
+        "disableMultisampledRenderToTexture", FeatureCategory::OpenGLWorkarounds,
+        "Many drivers have bugs when using GL_EXT_multisampled_render_to_texture", &members,
+        "http://anglebug.com/2894"};
+
+    FeatureInfo uploadTextureDataInChunks = {
+        "uploadTextureDataInChunks", FeatureCategory::OpenGLWorkarounds,
+        "Upload texture data in <120kb chunks to work around Mac driver hangs and crashes.",
+        &members, "http://crbug.com/1181068"};
+
+    FeatureInfo emulateImmutableCompressedTexture3D = {
+        "emulateImmutableCompressedTexture3D", FeatureCategory::OpenGLWorkarounds,
+        "Use non-immutable texture allocation to work around a driver bug.", &members,
+        "https://crbug.com/1060012"};
+
+    FeatureInfo emulateRGB10 = {"emulateRGB10", FeatureCategory::OpenGLWorkarounds,
+                                "Emulate RGB10 support using RGB10_A2.", &members,
+                                "https://crbug.com/1300575"};
+
+    FeatureInfo alwaysUnbindFramebufferTexture2D = {
+        "alwaysUnbindFramebufferTexture2D", FeatureCategory::OpenGLWorkarounds,
+        "Force unbind framebufferTexture2D before binding renderbuffer to work around driver bug.",
+        &members, "https://anglebug.com/5536"};
+
+    FeatureInfo disableTextureClampToBorder = {
+        "disableTextureClampToBorder", FeatureCategory::OpenGLWorkarounds,
+        "Imagination devices generate INVALID_ENUM when setting the texture border color.",
+        &members, "https://anglebug.com/7405"};
+
+    FeatureInfo passHighpToPackUnormSnormBuiltins = {
+        "passHighpToPackUnormSnormBuiltins", FeatureCategory::OpenGLWorkarounds,
+        "packUnorm4x8 fails on Pixel 4 if it is not passed a highp vec4.", &members,
+        "http://anglebug.com/7527"};
+
+    FeatureInfo supportsFragmentShaderInterlockNV = {
+        "supportsFragmentShaderInterlockNV", FeatureCategory::OpenGLFeatures,
+        "Backend GL context supports NV_fragment_shader_interlock extension", &members,
+        "http://anglebug.com/7279"};
+
+    FeatureInfo supportsFragmentShaderOrderingINTEL = {
+        "supportsFragmentShaderOrderingINTEL", FeatureCategory::OpenGLFeatures,
+        "Backend GL context supports GL_INTEL_fragment_shader_ordering extension", &members,
+        "http://anglebug.com/7279"};
+
+    FeatureInfo supportsFragmentShaderInterlockARB = {
+        "supportsFragmentShaderInterlockARB", FeatureCategory::OpenGLFeatures,
+        "Backend GL context supports ARB_fragment_shader_interlock extension", &members,
+        "http://anglebug.com/7279"};
+
+    FeatureInfo supportsShaderFramebufferFetchEXT = {
+        "supportsShaderFramebufferFetchEXT", FeatureCategory::OpenGLFeatures,
+        "Backend GL context supports EXT_shader_framebuffer_fetch extension", &members,
+        "http://anglebug.com/7279"};
+
+    FeatureInfo supportsShaderFramebufferFetchNonCoherentEXT = {
+        "supportsShaderFramebufferFetchNonCoherentEXT", FeatureCategory::OpenGLFeatures,
+        "Backend GL context supports EXT_shader_framebuffer_fetch_non_coherent extension", &members,
+        "http://anglebug.com/7279"};
+};
+
+inline FeaturesGL::FeaturesGL()  = default;
+inline FeaturesGL::~FeaturesGL() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_FEATURESGL_H_
diff --git a/gfx/angle/checkout/include/platform/FeaturesMtl_autogen.h b/gfx/angle/checkout/include/platform/FeaturesMtl_autogen.h
new file mode 100644
index 0000000000..116a0ee8d7
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/FeaturesMtl_autogen.h
@@ -0,0 +1,242 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_features.py using data from mtl_features.json.
+//
+// Copyright 2022 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.
+//
+// FeaturesMtl_autogen.h: Optional features for the Metal renderer.
+
+#ifndef ANGLE_PLATFORM_FEATURESMTL_H_
+#define ANGLE_PLATFORM_FEATURESMTL_H_
+
+#include "platform/Feature.h"
+
+namespace angle
+{
+
+struct FeaturesMtl : FeatureSetBase
+{
+    FeaturesMtl();
+    ~FeaturesMtl();
+
+    FeatureInfo hasBaseVertexInstancedDraw = {
+        "hasBaseVertexInstancedDraw",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports base vertex instanced draw",
+        &members,
+    };
+
+    FeatureInfo hasExplicitMemBarrier = {
+        "hasExplicitMemBarrier",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports explicit memory barrier",
+        &members,
+    };
+
+    FeatureInfo hasCheapRenderPass = {
+        "hasCheapRenderPass",
+        FeatureCategory::MetalFeatures,
+        "The renderer can cheaply break a render pass.",
+        &members,
+    };
+
+    FeatureInfo hasNonUniformDispatch = {
+        "hasNonUniformDispatch",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports non uniform compute shader dispatch's group size",
+        &members,
+    };
+
+    FeatureInfo hasShaderStencilOutput = {
+        "hasShaderStencilOutput",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports stencil output from fragment shader",
+        &members,
+    };
+
+    FeatureInfo hasTextureSwizzle = {
+        "hasTextureSwizzle",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports texture swizzle",
+        &members,
+    };
+
+    FeatureInfo hasDepthAutoResolve = {
+        "hasDepthAutoResolve",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports MSAA depth auto resolve at the end of render pass",
+        &members,
+    };
+
+    FeatureInfo hasStencilAutoResolve = {
+        "hasStencilAutoResolve",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports MSAA stencil auto resolve at the end of render pass",
+        &members,
+    };
+
+    FeatureInfo hasEvents = {
+        "hasEvents",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports MTL(Shared)Event",
+        &members,
+    };
+
+    FeatureInfo allowInlineConstVertexData = {
+        "allowInlineConstVertexData",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports using inline constant data for small client vertex data",
+        &members,
+    };
+
+    FeatureInfo allowSeparateDepthStencilBuffers = {
+        "allowSeparateDepthStencilBuffers",
+        FeatureCategory::MetalFeatures,
+        "Some Apple platforms such as iOS allows separate depth and stencil buffers, "
+        "whereas others such as macOS don't",
+        &members,
+    };
+
+    FeatureInfo allowRuntimeSamplerCompareMode = {
+        "allowRuntimeSamplerCompareMode",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports changing sampler's compare mode outside shaders",
+        &members,
+    };
+
+    FeatureInfo allowSamplerCompareGradient = {
+        "allowSamplerCompareGradient",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports sample_compare with gradients",
+        &members,
+    };
+
+    FeatureInfo allowSamplerCompareLod = {
+        "allowSamplerCompareLod",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports sample_compare with lod",
+        &members,
+    };
+
+    FeatureInfo allowBufferReadWrite = {
+        "allowBufferReadWrite",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports buffer read and write in the same shader",
+        &members,
+    };
+
+    FeatureInfo allowMultisampleStoreAndResolve = {
+        "allowMultisampleStoreAndResolve",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports MSAA store and resolve in the same pass",
+        &members,
+    };
+
+    FeatureInfo allowGenMultipleMipsPerPass = {
+        "allowGenMultipleMipsPerPass",
+        FeatureCategory::MetalFeatures,
+        "The renderer supports generating multiple mipmaps per pass",
+        &members,
+    };
+
+    FeatureInfo forceD24S8AsUnsupported = {
+        "forceD24S8AsUnsupported",
+        FeatureCategory::MetalFeatures,
+        "Force Depth24Stencil8 format as unsupported.",
+        &members,
+    };
+
+    FeatureInfo forceBufferGPUStorage = {
+        "forceBufferGPUStorage",
+        FeatureCategory::MetalFeatures,
+        "On systems that support both buffer' memory allocation on GPU and shared memory (such as "
+        "macOS), force using GPU memory allocation for buffers everytime or not.",
+        &members,
+    };
+
+    FeatureInfo directMetalGeneration = {"directMetalGeneration", FeatureCategory::MetalFeatures,
+                                         "Direct translation to Metal.", &members,
+                                         "http://anglebug.com/5505"};
+
+    FeatureInfo forceNonCSBaseMipmapGeneration = {
+        "forceNonCSBaseMipmapGeneration",
+        FeatureCategory::MetalFeatures,
+        "Turn this feature on to disallow Compute Shader based mipmap generation. Compute Shader "
+        "based mipmap generation might cause GPU hang on some older iOS devices.",
+        &members,
+    };
+
+    FeatureInfo emulateTransformFeedback = {
+        "emulateTransformFeedback",
+        FeatureCategory::MetalFeatures,
+        "Turn this on to allow transform feedback in Metal using a 2-pass VS for GLES3.",
+        &members,
+    };
+
+    FeatureInfo rewriteRowMajorMatrices = {
+        "rewriteRowMajorMatrices",
+        FeatureCategory::MetalFeatures,
+        "Rewrite row major matrices in shaders as column major.",
+        &members,
+    };
+
+    FeatureInfo intelExplicitBoolCastWorkaround = {
+        "intelExplicitBoolCastWorkaround",
+        FeatureCategory::MetalWorkarounds,
+        "Insert explicit casts for float/double/unsigned/signed int on macOS 10.15 with Intel "
+        "driver",
+        &members,
+    };
+
+    FeatureInfo intelDisableFastMath = {
+        "intelDisableFastMath",
+        FeatureCategory::MetalWorkarounds,
+        "Disable fast math in atan and invariance cases when running below macOS 12.0",
+        &members,
+    };
+
+    FeatureInfo multisampleColorFormatShaderReadWorkaround = {
+        "multisampleColorFormatShaderReadWorkaround", FeatureCategory::MetalWorkarounds,
+        "Add shaderRead usage to some multisampled texture formats", &members,
+        "http://anglebug.com/7049"};
+
+    FeatureInfo copyIOSurfaceToNonIOSurfaceForReadOptimization = {
+        "copyIOSurfaceToNonIOSurfaceForReadOptimization", FeatureCategory::MetalWorkarounds,
+        "some GPUs are faster to read an IOSurface texture by first copying the texture to a "
+        "non-IOSurface texture",
+        &members, "http://anglebug.com/7117 http://anglebug.com/7573"};
+
+    FeatureInfo copyTextureToBufferForReadOptimization = {
+        "copyTextureToBufferForReadOptimization", FeatureCategory::MetalWorkarounds,
+        "some GPUs are faster to read a texture by first copying the texture to a buffer", &members,
+        "http://anglebug.com/7117"};
+
+    FeatureInfo limitMaxDrawBuffersForTesting = {
+        "limitMaxDrawBuffersForTesting", FeatureCategory::MetalFeatures,
+        "Used to check the backend works when the device's advertized limit is less than the "
+        "code's limit",
+        &members, "http://anglebug.com/7280"};
+
+    FeatureInfo limitMaxColorTargetBitsForTesting = {
+        "limitMaxColorTargetBitsForTesting", FeatureCategory::MetalFeatures,
+        "Metal iOS has a limit on the number of color target bits per pixel.", &members,
+        "http://anglebug.com/7280"};
+
+    FeatureInfo preemptivelyStartProvokingVertexCommandBuffer = {
+        "preemptivelyStartProvokingVertexCommandBuffer", FeatureCategory::MetalFeatures,
+        "AMD Metal Drivers appear to have a bug this works around", &members,
+        "http://anglebug.com/7635"};
+
+    FeatureInfo uploadDataToIosurfacesWithStagingBuffers = {
+        "uploadDataToIosurfacesWithStagingBuffers", FeatureCategory::MetalWorkarounds,
+        "When uploading data to IOSurface-backed textures, use a staging buffer.", &members,
+        "http://anglebug.com/7573"};
+};
+
+inline FeaturesMtl::FeaturesMtl()  = default;
+inline FeaturesMtl::~FeaturesMtl() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_FEATURESMTL_H_
diff --git a/gfx/angle/checkout/include/platform/FeaturesVk_autogen.h b/gfx/angle/checkout/include/platform/FeaturesVk_autogen.h
new file mode 100644
index 0000000000..dadd64c49b
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/FeaturesVk_autogen.h
@@ -0,0 +1,786 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_features.py using data from vk_features.json.
+//
+// Copyright 2022 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.
+//
+// FeaturesVk_autogen.h: Optional features for the Vulkan renderer.
+
+#ifndef ANGLE_PLATFORM_FEATURESVK_H_
+#define ANGLE_PLATFORM_FEATURESVK_H_
+
+#include "platform/Feature.h"
+
+namespace angle
+{
+
+struct FeaturesVk : FeatureSetBase
+{
+    FeaturesVk();
+    ~FeaturesVk();
+
+    FeatureInfo bresenhamLineRasterization = {
+        "bresenhamLineRasterization",
+        FeatureCategory::VulkanFeatures,
+        "Enable Bresenham line rasterization via VK_EXT_line_rasterization extension",
+        &members,
+    };
+
+    FeatureInfo provokingVertex = {
+        "provokingVertex",
+        FeatureCategory::VulkanFeatures,
+        "Enable provoking vertex mode via VK_EXT_provoking_vertex extension",
+        &members,
+    };
+
+    FeatureInfo forceFallbackFormat = {
+        "forceFallbackFormat",
+        FeatureCategory::VulkanWorkarounds,
+        "Force a fallback format for angle_end2end_tests",
+        &members,
+    };
+
+    FeatureInfo clampPointSize = {
+        "clampPointSize", FeatureCategory::VulkanWorkarounds,
+        "The point size range reported from the API is inconsistent with the actual behavior",
+        &members, "http://anglebug.com/2970"};
+
+    FeatureInfo depthClamping = {
+        "depthClamping", FeatureCategory::VulkanWorkarounds,
+        "The depth value is not clamped to [0,1] for floating point depth buffers.", &members,
+        "http://anglebug.com/3970"};
+
+    FeatureInfo mutableMipmapTextureUpload = {
+        "mutableMipmapTextureUpload", FeatureCategory::VulkanFeatures,
+        "Enable uploading the previously defined mutable mipmap texture.", &members,
+        "https://anglebug.com/7308"};
+
+    FeatureInfo supportsRenderpass2 = {
+        "supportsRenderpass2",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_create_renderpass2 extension",
+        &members,
+    };
+
+    FeatureInfo supportsIncrementalPresent = {
+        "supportsIncrementalPresent",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_incremental_present extension",
+        &members,
+    };
+
+    FeatureInfo supportsAndroidHardwareBuffer = {
+        "supportsAndroidHardwareBuffer",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_ANDROID_external_memory_android_hardware_buffer extension",
+        &members,
+    };
+
+    FeatureInfo supportsGGPFrameToken = {
+        "supportsGGPFrameToken",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_GGP_frame_token extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalMemoryFd = {
+        "supportsExternalMemoryFd",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_external_memory_fd extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalMemoryFuchsia = {
+        "supportsExternalMemoryFuchsia",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_FUCHSIA_external_memory extension",
+        &members,
+    };
+
+    FeatureInfo supportsFilteringPrecision = {
+        "supportsFilteringPrecision",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_GOOGLE_sampler_filtering_precision extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalFenceCapabilities = {
+        "supportsExternalFenceCapabilities",
+        FeatureCategory::VulkanFeatures,
+        "VkInstance supports the VK_KHR_external_fence_capabilities extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalSemaphoreCapabilities = {
+        "supportsExternalSemaphoreCapabilities",
+        FeatureCategory::VulkanFeatures,
+        "VkInstance supports the VK_KHR_external_semaphore_capabilities extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalSemaphoreFd = {
+        "supportsExternalSemaphoreFd",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_external_semaphore_fd extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalSemaphoreFuchsia = {
+        "supportsExternalSemaphoreFuchsia",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_FUCHSIA_external_semaphore extension",
+        &members,
+    };
+
+    FeatureInfo supportsExternalFenceFd = {
+        "supportsExternalFenceFd", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_external_fence_fd extension", &members,
+        "http://anglebug.com/2517"};
+
+    FeatureInfo supportsAndroidNativeFenceSync = {
+        "supportsAndroidNativeFenceSync", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the EGL_ANDROID_native_fence_sync extension", &members,
+        "http://anglebug.com/2517"};
+
+    FeatureInfo supportsImageCubeArray = {"supportsImageCubeArray", FeatureCategory::VulkanFeatures,
+                                          "VkDevice supports the imageCubeArray feature properly",
+                                          &members, "http://anglebug.com/3584"};
+
+    FeatureInfo supportsPipelineStatisticsQuery = {
+        "supportsPipelineStatisticsQuery", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the pipelineStatisticsQuery feature", &members,
+        "http://anglebug.com/5430"};
+
+    FeatureInfo supportsShaderStencilExport = {
+        "supportsShaderStencilExport",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_shader_stencil_export extension",
+        &members,
+    };
+
+    FeatureInfo supportsYUVSamplerConversion = {
+        "supportsYUVSamplerConversion",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_sampler_ycbcr_conversion extension",
+        &members,
+    };
+
+    FeatureInfo emulateTransformFeedback = {
+        "emulateTransformFeedback", FeatureCategory::VulkanFeatures,
+        "Emulate transform feedback as the VK_EXT_transform_feedback is not present.", &members,
+        "http://anglebug.com/3205"};
+
+    FeatureInfo supportsTransformFeedbackExtension = {
+        "supportsTransformFeedbackExtension", FeatureCategory::VulkanFeatures,
+        "Transform feedback uses the VK_EXT_transform_feedback extension.", &members,
+        "http://anglebug.com/3206"};
+
+    FeatureInfo supportsGeometryStreamsCapability = {
+        "supportsGeometryStreamsCapability", FeatureCategory::VulkanFeatures,
+        "Implementation supports the GeometryStreams SPIR-V capability.", &members,
+        "http://anglebug.com/3206"};
+
+    FeatureInfo supportsIndexTypeUint8 = {"supportsIndexTypeUint8", FeatureCategory::VulkanFeatures,
+                                          "VkDevice supports the VK_EXT_index_type_uint8 extension",
+                                          &members, "http://anglebug.com/4405"};
+
+    FeatureInfo supportsCustomBorderColor = {
+        "supportsCustomBorderColor", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_custom_border_color extension", &members,
+        "http://anglebug.com/3577"};
+
+    FeatureInfo supportsMultiDrawIndirect = {
+        "supportsMultiDrawIndirect", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the multiDrawIndirect extension", &members, "http://anglebug.com/6439"};
+
+    FeatureInfo supportsDepthStencilResolve = {"supportsDepthStencilResolve",
+                                               FeatureCategory::VulkanFeatures,
+                                               "VkDevice supports the VK_KHR_depth_stencil_resolve "
+                                               "extension with the independentResolveNone feature",
+                                               &members, "http://anglebug.com/4836"};
+
+    FeatureInfo supportsMultisampledRenderToSingleSampledGOOGLEX = {
+        "supportsMultisampledRenderToSingleSampledGOOGLEX", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_GOOGLEX_multisampled_render_to_single_sampled extension",
+        &members, "http://anglebug.com/4836"};
+
+    FeatureInfo supportsMultisampledRenderToSingleSampled = {
+        "supportsMultisampledRenderToSingleSampled", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_multisampled_render_to_single_sampled extension", &members,
+        "http://anglebug.com/4836"};
+
+    FeatureInfo supportsMultiview = {"supportsMultiview", FeatureCategory::VulkanFeatures,
+                                     "VkDevice supports the VK_KHR_multiview extension", &members,
+                                     "http://anglebug.com/6048"};
+
+    FeatureInfo disableFifoPresentMode = {
+        "disableFifoPresentMode", FeatureCategory::VulkanWorkarounds,
+        "VK_PRESENT_MODE_FIFO_KHR causes random timeouts", &members, "http://anglebug.com/3153"};
+
+    FeatureInfo forceD16TexFilter = {
+        "forceD16TexFilter", FeatureCategory::VulkanWorkarounds,
+        "VK_FORMAT_D16_UNORM does not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "
+        "which prevents OES_depth_texture from being supported.",
+        &members, "http://anglebug.com/3452"};
+
+    FeatureInfo disableFlippingBlitWithCommand = {
+        "disableFlippingBlitWithCommand", FeatureCategory::VulkanWorkarounds,
+        "vkCmdBlitImage with flipped coordinates blits incorrectly.", &members,
+        "http://anglebug.com/3498"};
+
+    FeatureInfo perFrameWindowSizeQuery = {
+        "perFrameWindowSizeQuery", FeatureCategory::VulkanWorkarounds,
+        "Vulkan swapchain is not returning VK_ERROR_OUT_OF_DATE when window resizing", &members,
+        "http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625"};
+
+    FeatureInfo padBuffersToMaxVertexAttribStride = {
+        "padBuffersToMaxVertexAttribStride", FeatureCategory::VulkanWorkarounds,
+        "Vulkan considers vertex attribute accesses to count up to the last multiple of the "
+        "stride. This additional access supports AMD's robust buffer access implementation. "
+        "AMDVLK in particular will return incorrect values when the vertex access extends into "
+        "the range that would be the stride padding and the buffer is too small. "
+        "This workaround limits GL_MAX_VERTEX_ATTRIB_STRIDE to a maximum value and "
+        "pads up every buffer allocation size to be a multiple of the maximum stride.",
+        &members, "http://anglebug.com/4428"};
+
+    FeatureInfo supportsExternalMemoryDmaBufAndModifiers = {
+        "supportsExternalMemoryDmaBufAndModifiers", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_external_memory_dma_buf and VK_EXT_image_drm_format_modifier "
+        "extensions",
+        &members, "http://anglebug.com/6248"};
+
+    FeatureInfo supportsExternalMemoryHost = {
+        "supportsExternalMemoryHost",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_external_memory_host extension",
+        &members,
+    };
+
+    FeatureInfo allocateNonZeroMemory = {
+        "allocateNonZeroMemory", FeatureCategory::VulkanFeatures,
+        "Fill new allocations with non-zero values to flush out errors.", &members,
+        "http://anglebug.com/4384"};
+
+    FeatureInfo logMemoryReportCallbacks = {
+        "logMemoryReportCallbacks",
+        FeatureCategory::VulkanFeatures,
+        "Log each callback from VK_EXT_device_memory_report",
+        &members,
+    };
+
+    FeatureInfo logMemoryReportStats = {
+        "logMemoryReportStats",
+        FeatureCategory::VulkanFeatures,
+        "Log stats from VK_EXT_device_memory_report each swap",
+        &members,
+    };
+
+    FeatureInfo shadowBuffers = {
+        "shadowBuffers", FeatureCategory::VulkanFeatures,
+        "Allocate a shadow buffer for GL buffer objects to reduce glMap* latency.", &members,
+        "http://anglebug.com/4339"};
+
+    FeatureInfo preferCPUForBufferSubData = {
+        "preferCPUForBufferSubData", FeatureCategory::VulkanFeatures,
+        "Prefer use CPU to do bufferSubData instead of staged update.", &members,
+        "http://issuetracker.google.com/200067929"};
+
+    FeatureInfo persistentlyMappedBuffers = {
+        "persistentlyMappedBuffers", FeatureCategory::VulkanFeatures,
+        "Persistently map buffer memory to reduce map/unmap IOCTL overhead.", &members,
+        "http://anglebug.com/2162"};
+
+    FeatureInfo enablePreRotateSurfaces = {"enablePreRotateSurfaces",
+                                           FeatureCategory::VulkanFeatures,
+                                           "Enable Android pre-rotation for landscape applications",
+                                           &members, "http://anglebug.com/3502"};
+
+    FeatureInfo enablePrecisionQualifiers = {
+        "enablePrecisionQualifiers", FeatureCategory::VulkanFeatures,
+        "Enable precision qualifiers in shaders", &members, "http://anglebug.com/3078"};
+
+    FeatureInfo preferAggregateBarrierCalls = {
+        "preferAggregateBarrierCalls", FeatureCategory::VulkanWorkarounds,
+        "Single barrier call is preferred over multiple calls with "
+        "fine grained pipeline stage dependency information",
+        &members, "http://anglebug.com/4633"};
+
+    FeatureInfo preferSkippingInvalidateForEmulatedFormats = {
+        "preferSkippingInvalidateForEmulatedFormats", FeatureCategory::VulkanWorkarounds,
+        "Skipping invalidate is preferred for emulated formats that have extra channels over "
+        "re-clearing the image",
+        &members, "http://anglebug.com/6860"};
+
+    FeatureInfo asyncCommandQueue = {"asyncCommandQueue", FeatureCategory::VulkanFeatures,
+                                     "Use CommandQueue worker thread to dispatch work to GPU.",
+                                     &members, "http://anglebug.com/4324"};
+
+    FeatureInfo supportsShaderFloat16 = {
+        "supportsShaderFloat16", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_KHR_shader_float16_int8 extension "
+        "and has the shaderFloat16 feature",
+        &members, "http://anglebug.com/4551"};
+
+    FeatureInfo allowGenerateMipmapWithCompute = {
+        "allowGenerateMipmapWithCompute", FeatureCategory::VulkanFeatures,
+        "Use the compute path to generate mipmaps on devices that meet the minimum requirements, "
+        "and the performance is better.",
+        &members, "http://anglebug.com/4551"};
+
+    FeatureInfo supportsRenderPassStoreOpNone = {
+        "supportsRenderPassStoreOpNone", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_QCOM_render_pass_store_ops extension.", &members,
+        "http://anglebug.com/5055"};
+
+    FeatureInfo supportsRenderPassLoadStoreOpNone = {
+        "supportsRenderPassLoadStoreOpNone", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_load_store_op_none extension.", &members,
+        "http://anglebug.com/5371"};
+
+    FeatureInfo disallowMixedDepthStencilLoadOpNoneAndLoad = {
+        "disallowMixedDepthStencilLoadOpNoneAndLoad", FeatureCategory::VulkanWorkarounds,
+        "Disallow use of LOAD_OP_NONE for only one of the depth or stencil aspects of a "
+        "depth/stencil attachment",
+        &members, "http://anglebug.com/7370"};
+
+    FeatureInfo supportsDepthClipControl = {
+        "supportsDepthClipControl", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_depth_clip_control extension.", &members,
+        "http://anglebug.com/5421"};
+
+    FeatureInfo supportsPrimitiveTopologyListRestart = {
+        "supportsPrimitiveTopologyListRestart", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_primitive_topology_list_restart extension.", &members,
+        "http://anglebug.com/3832"};
+
+    FeatureInfo supportsBlendOperationAdvanced = {
+        "supportsBlendOperationAdvanced", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_blend_operation_advanced extension.", &members,
+        "http://anglebug.com/3586"};
+
+    FeatureInfo forceMaxUniformBufferSize16KB = {
+        "forceMaxUniformBufferSize16KB", FeatureCategory::VulkanWorkarounds,
+        "Force max uniform buffer size to 16K on some device due to bug", &members,
+        "https://issuetracker.google.com/161903006"};
+
+    FeatureInfo supportsImageFormatList = {
+        "supportsImageFormatList", FeatureCategory::VulkanFeatures,
+        "Enable VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT by default for ICDs "
+        "that support VK_KHR_image_format_list",
+        &members, "http://anglebug.com/5281"};
+
+    FeatureInfo enableMultisampledRenderToTexture = {
+        "enableMultisampledRenderToTexture", FeatureCategory::VulkanWorkarounds,
+        "Expose EXT_multisampled_render_to_texture", &members, "http://anglebug.com/4937"};
+
+    FeatureInfo deferFlushUntilEndRenderPass = {
+        "deferFlushUntilEndRenderPass", FeatureCategory::VulkanWorkarounds,
+        "Allow glFlush to be deferred until renderpass ends", &members,
+        "https://issuetracker.google.com/issues/166475273"};
+
+    FeatureInfo waitIdleBeforeSwapchainRecreation = {
+        "waitIdleBeforeSwapchainRecreation", FeatureCategory::VulkanWorkarounds,
+        "Before passing an oldSwapchain to VkSwapchainCreateInfoKHR, wait for queue to be idle. "
+        "Works around a bug on platforms which destroy oldSwapchain in vkCreateSwapchainKHR.",
+        &members, "http://anglebug.com/5061"};
+
+    FeatureInfo forceTextureLodOffset1 = {
+        "forceTextureLodOffset1",
+        FeatureCategory::VulkanWorkarounds,
+        "Increase the minimum texture level-of-detail by 1 when sampling.",
+        &members,
+    };
+
+    FeatureInfo forceTextureLodOffset2 = {
+        "forceTextureLodOffset2",
+        FeatureCategory::VulkanWorkarounds,
+        "Increase the minimum texture level-of-detail by 2 when sampling.",
+        &members,
+    };
+
+    FeatureInfo forceTextureLodOffset3 = {
+        "forceTextureLodOffset3",
+        FeatureCategory::VulkanWorkarounds,
+        "Increase the minimum texture level-of-detail by 3 when sampling.",
+        &members,
+    };
+
+    FeatureInfo forceTextureLodOffset4 = {
+        "forceTextureLodOffset4",
+        FeatureCategory::VulkanWorkarounds,
+        "Increase the minimum texture level-of-detail by 4 when sampling.",
+        &members,
+    };
+
+    FeatureInfo forceNearestFiltering = {
+        "forceNearestFiltering",
+        FeatureCategory::VulkanWorkarounds,
+        "Force nearest filtering when sampling.",
+        &members,
+    };
+
+    FeatureInfo forceNearestMipFiltering = {
+        "forceNearestMipFiltering",
+        FeatureCategory::VulkanWorkarounds,
+        "Force nearest mip filtering when sampling.",
+        &members,
+    };
+
+    FeatureInfo compressVertexData = {
+        "compressVertexData",
+        FeatureCategory::VulkanWorkarounds,
+        "Compress vertex data to smaller data types when "
+        "possible. Using this feature makes ANGLE non-conformant.",
+        &members,
+    };
+
+    FeatureInfo preferDrawClearOverVkCmdClearAttachments = {
+        "preferDrawClearOverVkCmdClearAttachments", FeatureCategory::VulkanWorkarounds,
+        "On some hardware, clear using a draw call instead of vkCmdClearAttachments in the middle "
+        "of render pass due to bugs",
+        &members, "https://issuetracker.google.com/166809097"};
+
+    FeatureInfo emulatedPrerotation90 = {"emulatedPrerotation90", FeatureCategory::VulkanFeatures,
+                                         "Emulate 90-degree prerotation.", &members,
+                                         "http://anglebug.com/4901"};
+
+    FeatureInfo emulatedPrerotation180 = {"emulatedPrerotation180", FeatureCategory::VulkanFeatures,
+                                          "Emulate 180-degree prerotation.", &members,
+                                          "http://anglebug.com/4901"};
+
+    FeatureInfo emulatedPrerotation270 = {"emulatedPrerotation270", FeatureCategory::VulkanFeatures,
+                                          "Emulate 270-degree prerotation.", &members,
+                                          "http://anglebug.com/4901"};
+
+    FeatureInfo generateSPIRVThroughGlslang = {
+        "generateSPIRVThroughGlslang", FeatureCategory::VulkanFeatures,
+        "Translate SPIR-V through glslang.", &members, "http://anglebug.com/4889"};
+
+    FeatureInfo preferDriverUniformOverSpecConst = {
+        "preferDriverUniformOverSpecConst", FeatureCategory::VulkanFeatures,
+        "Prefer using driver uniforms instead of specialization constants.", &members,
+        "http://anglebug.com/7406"};
+
+    FeatureInfo exposeNonConformantExtensionsAndVersions = {
+        "exposeNonConformantExtensionsAndVersions", FeatureCategory::VulkanWorkarounds,
+        "Expose GLES versions and extensions that are not conformant.", &members,
+        "http://anglebug.com/5375"};
+
+    FeatureInfo emulateR32fImageAtomicExchange = {
+        "emulateR32fImageAtomicExchange", FeatureCategory::VulkanWorkarounds,
+        "Emulate r32f images with r32ui to support imageAtomicExchange.", &members,
+        "http://anglebug.com/5535"};
+
+    FeatureInfo supportsNegativeViewport = {
+        "supportsNegativeViewport",
+        FeatureCategory::VulkanFeatures,
+        "The driver supports inverting the viewport with a negative height.",
+        &members,
+    };
+
+    FeatureInfo forceFragmentShaderPrecisionHighpToMediump = {
+        "forceFragmentShaderPrecisionHighpToMediump", FeatureCategory::VulkanWorkarounds,
+        "Forces highp precision in fragment shader to mediump.", &members,
+        "https://issuetracker.google.com/184850002"};
+
+    FeatureInfo preferSubmitAtFBOBoundary = {
+        "preferSubmitAtFBOBoundary", FeatureCategory::VulkanWorkarounds,
+        "Submit commands to driver at each FBO boundary for performance improvements.", &members,
+        "https://issuetracker.google.com/187425444"};
+
+    FeatureInfo useMultipleDescriptorsForExternalFormats = {
+        "useMultipleDescriptorsForExternalFormats", FeatureCategory::VulkanWorkarounds,
+        "Return a default descriptor count for external formats.", &members,
+        "http://anglebug.com/6141"};
+
+    FeatureInfo supportsProtectedMemory = {
+        "supportsProtectedMemory", FeatureCategory::VulkanFeatures,
+        "VkDevice supports protected memory", &members, "http://anglebug.com/3965"};
+
+    FeatureInfo supportsHostQueryReset = {"supportsHostQueryReset", FeatureCategory::VulkanFeatures,
+                                          "VkDevice supports VK_EXT_host_query_reset extension",
+                                          &members, "http://anglebug.com/6692"};
+
+    FeatureInfo supportsPipelineCreationCacheControl = {
+        "supportsPipelineCreationCacheControl", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_pipeline_creation_cache_control extension", &members,
+        "http://anglebug.com/5881"};
+
+    FeatureInfo supportsPipelineCreationFeedback = {
+        "supportsPipelineCreationFeedback", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_pipeline_creation_feedback extension", &members,
+        "http://anglebug.com/5881"};
+
+    FeatureInfo supportsPrimitivesGeneratedQuery = {
+        "supportsPrimitivesGeneratedQuery", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_primitives_generated_query extension", &members,
+        "http://anglebug.com/5430"};
+
+    FeatureInfo supportsSurfaceCapabilities2Extension = {
+        "supportsSurfaceCapabilities2Extension",
+        FeatureCategory::VulkanFeatures,
+        "VkInstance supports the VK_KHR_get_surface_capabilities2 extension",
+        &members,
+    };
+
+    FeatureInfo supportsSurfaceProtectedCapabilitiesExtension = {
+        "supportsSurfaceProtectedCapabilitiesExtension",
+        FeatureCategory::VulkanFeatures,
+        "VkInstance supports the VK_KHR_surface_protected_capabilities extension",
+        &members,
+    };
+
+    FeatureInfo supportsSurfacelessQueryExtension = {
+        "supportsSurfacelessQueryExtension",
+        FeatureCategory::VulkanFeatures,
+        "VkInstance supports the VK_GOOGLE_surfaceless_query extension",
+        &members,
+    };
+
+    FeatureInfo supportsSurfaceProtectedSwapchains = {
+        "supportsSurfaceProtectedSwapchains",
+        FeatureCategory::VulkanFeatures,
+        "VkSurface supportsProtected for protected swapchains",
+        &members,
+    };
+
+    FeatureInfo overrideSurfaceFormatRGB8ToRGBA8 = {
+        "overrideSurfaceFormatRGB8ToRGBA8", FeatureCategory::VulkanWorkarounds,
+        "Override surface format GL_RGB8 to GL_RGBA8", &members, "http://anglebug.com/6651"};
+
+    FeatureInfo supportsSharedPresentableImageExtension = {
+        "supportsSharedPresentableImageExtension",
+        FeatureCategory::VulkanFeatures,
+        "VkSurface supports the VK_KHR_shared_presentable_images extension",
+        &members,
+    };
+
+    FeatureInfo supportsShaderFramebufferFetch = {
+        "supportsShaderFramebufferFetch",
+        FeatureCategory::VulkanFeatures,
+        "Whether the Vulkan backend supports coherent framebuffer fetch",
+        &members,
+    };
+
+    FeatureInfo supportsShaderFramebufferFetchNonCoherent = {
+        "supportsShaderFramebufferFetchNonCoherent",
+        FeatureCategory::VulkanFeatures,
+        "Whether the Vulkan backend supports non-coherent framebuffer fetch",
+        &members,
+    };
+
+    FeatureInfo permanentlySwitchToFramebufferFetchMode = {
+        "permanentlySwitchToFramebufferFetchMode",
+        FeatureCategory::VulkanFeatures,
+        "Whether the context should permanently switch to framebuffer fetch mode on first"
+        "encounter",
+        &members,
+    };
+
+    FeatureInfo supportsLockSurfaceExtension = {
+        "supportsLockSurfaceExtension",
+        FeatureCategory::VulkanFeatures,
+        "Surface supports the EGL_KHR_lock_surface3 extension",
+        &members,
+    };
+
+    FeatureInfo swapbuffersOnFlushOrFinishWithSingleBuffer = {
+        "swapbuffersOnFlushOrFinishWithSingleBuffer", FeatureCategory::VulkanFeatures,
+        "Bypass deferredFlush with calling swapbuffers on flush or finish when in Shared "
+        "Present mode",
+        &members, "http://anglebug.com/6878"};
+
+    FeatureInfo emulateDithering = {"emulateDithering", FeatureCategory::VulkanFeatures,
+                                    "Emulate OpenGL dithering", &members,
+                                    "http://anglebug.com/6755"};
+
+    FeatureInfo roundOutputAfterDithering = {
+        "roundOutputAfterDithering", FeatureCategory::VulkanWorkarounds,
+        "Round output after dithering to workaround a driver bug that rounds the output up",
+        &members, "http://anglebug.com/6953"};
+
+    FeatureInfo emulateAdvancedBlendEquations = {
+        "emulateAdvancedBlendEquations", FeatureCategory::VulkanFeatures,
+        "Emulate GL_KHR_blend_equation_advanced", &members, "http://anglebug.com/3586"};
+
+    FeatureInfo precisionSafeDivision = {
+        "precisionSafeDivision",
+        FeatureCategory::VulkanWorkarounds,
+        "Special case handling for platforms that do not generate 1.0f even when the dividend and"
+        "divisor have the same value",
+        &members,
+    };
+
+    FeatureInfo bottomLeftOriginPresentRegionRectangles = {
+        "bottomLeftOriginPresentRegionRectangles",
+        FeatureCategory::VulkanWorkarounds,
+        "On some platforms present region rectangles are expected to have a bottom-left origin, "
+        "instead of top-left origin as from spec",
+        &members,
+    };
+
+    FeatureInfo forceSubmitImmutableTextureUpdates = {
+        "forceSubmitImmutableTextureUpdates", FeatureCategory::VulkanAppWorkarounds,
+        "Force submit updates to immutable textures", &members, "http://anglebug.com/6929"};
+
+    FeatureInfo retainSPIRVDebugInfo = {"retainSPIRVDebugInfo", FeatureCategory::VulkanFeatures,
+                                        "Retain debug info in SPIR-V blob.", &members,
+                                        "http://anglebug.com/5901"};
+
+    FeatureInfo warmUpPipelineCacheAtLink = {
+        "warmUpPipelineCacheAtLink", FeatureCategory::VulkanFeatures,
+        "Warm up the Vulkan pipeline cache at link time", &members, "http://anglebug.com/5881"};
+
+    FeatureInfo preferDeviceLocalMemoryHostVisible = {
+        "preferDeviceLocalMemoryHostVisible", FeatureCategory::VulkanFeatures,
+        "Prefer adding HOST_VISIBLE flag for DEVICE_LOCAL memory when picking memory types",
+        &members, "http://anglebug.com/7047"};
+
+    FeatureInfo forceStaticVertexStrideState = {
+        "forceStaticVertexStrideState", FeatureCategory::VulkanWorkarounds,
+        "Force static state for VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT due to"
+        "driver bugs",
+        &members, "https://bugs.fuchsia.dev/p/fuchsia/issues/detail?id=107106"};
+
+    FeatureInfo supportsExtendedDynamicState = {
+        "supportsExtendedDynamicState", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_extended_dynamic_state extension", &members,
+        "http://anglebug.com/5906"};
+
+    FeatureInfo supportsExtendedDynamicState2 = {
+        "supportsExtendedDynamicState2", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_extended_dynamic_state2 extension", &members,
+        "http://anglebug.com/5906"};
+
+    FeatureInfo supportsLogicOpDynamicState = {
+        "supportsLogicOpDynamicState", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the logicOp feature of VK_EXT_extended_dynamic_state2 extension",
+        &members, "http://anglebug.com/3862"};
+
+    FeatureInfo supportsFragmentShadingRate = {
+        "supportsFragmentShadingRate", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_KHR_fragment_shading_rate extension", &members,
+        "http://anglebug.com/7172"};
+
+    FeatureInfo supportsFragmentShaderPixelInterlock = {
+        "supportsFragmentShaderPixelInterlock",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_fragment_shader_interlock extension "
+        "and has the fragmentShaderPixelInterlock feature",
+        &members,
+    };
+
+    FeatureInfo explicitlyEnablePerSampleShading = {
+        "explicitlyEnablePerSampleShading", FeatureCategory::VulkanWorkarounds,
+        "Explicitly enable per-sample shading if the fragment shader contains the "
+        "sample qualifier",
+        &members, "http://anglebug.com/6876"};
+
+    FeatureInfo forceContinuousRefreshOnSharedPresent = {
+        "forceContinuousRefreshOnSharedPresent", FeatureCategory::VulkanFeatures,
+        "Force to create vulkan swapchain with continuous refresh on shared present", &members,
+        "https://issuetracker.google.com/229267970"};
+
+    FeatureInfo supportsImage2dViewOf3d = {
+        "supportsImage2dViewOf3d", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_image_2d_view_of_3d", &members, "https://anglebug.com/7320"};
+
+    FeatureInfo supportsImagelessFramebuffer = {
+        "supportsImagelessFramebuffer", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_KHR_imageless_framebuffer extension", &members,
+        "http://anglebug.com/7553"};
+
+    FeatureInfo preferLinearFilterForYUV = {
+        "preferLinearFilterForYUV", FeatureCategory::VulkanFeatures,
+        "Prefer to use VK_FILTER_LINEAR for VkSamplerYcbcrConversion", &members,
+        "https://anglebug.com/7382"};
+
+    FeatureInfo supportsYuvTarget = {
+        "supportsYuvTarget",
+        FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_ANDROID_render_to_external_format and VK_EXT_ycbcr_attachment",
+        &members,
+    };
+
+    FeatureInfo useNonZeroStencilWriteMaskStaticState = {
+        "useNonZeroStencilWriteMaskStaticState", FeatureCategory::VulkanWorkarounds,
+        "Work around a driver bug where 0 in stencil write mask static state would make the"
+        "corresponding dynamic state malfunction in the presence of discard or alpha to coverage",
+        &members, "http://anglebug.com/7556"};
+
+    FeatureInfo mapUnspecifiedColorSpaceToPassThrough = {
+        "mapUnspecifiedColorSpaceToPassThrough",
+        FeatureCategory::VulkanFeatures,
+        "Use VK_COLOR_SPACE_PASS_THROUGH_EXT for EGL_NONE or unspecifed color "
+        "spaces",
+        &members,
+    };
+
+    FeatureInfo supportsTimestampSurfaceAttribute = {
+        "supportsTimestampSurfaceAttribute", FeatureCategory::VulkanFeatures,
+        "Platform supports setting frame timestamp surface attribute", &members,
+        "https://anglebug.com/7489"};
+
+    FeatureInfo supportsRasterizationOrderAttachmentAccess = {
+        "supportsRasterizationOrderAttachmentAccess", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_rasterization_order_attachment_access extension", &members,
+        "https://anglebug.com/7604"};
+
+    FeatureInfo eglColorspaceAttributePassthrough = {
+        "eglColorspaceAttributePassthrough", FeatureCategory::VulkanFeatures,
+        "Support passthrough of EGL colorspace attribute values", &members,
+        "https://anglebug.com/7319"};
+
+    FeatureInfo supportsPipelineRobustness = {
+        "supportsPipelineRobustness", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_pipeline_robustness extension", &members,
+        "https://anglebug.com/5845"};
+
+    FeatureInfo supportsVertexInputDynamicState = {
+        "supportsVertexInputDynamicState", FeatureCategory::VulkanFeatures,
+        "VkDevice supports VK_EXT_vertex_input_dynamic_state extension", &members,
+        "https://anglebug.com/7162"};
+
+    FeatureInfo supportsColorWriteEnable = {"supportsColorWriteEnable",
+                                            FeatureCategory::VulkanFeatures,
+                                            "VkDevice supports VK_EXT_color_write_enable extension",
+                                            &members, "https://anglebug.com/7161"};
+
+    FeatureInfo supportsPresentation = {
+        "supportsPresentation",
+        FeatureCategory::VulkanFeatures,
+        "VkDisplay supports presentation through a present family queue",
+        &members,
+    };
+
+    FeatureInfo supportsComputeTranscodeEtcToBc = {
+        "supportsComputeTranscodeEtcToBc",
+        FeatureCategory::VulkanFeatures,
+        "supports compute shader transcode etc format to bc format",
+        &members,
+    };
+
+    FeatureInfo supportsGraphicsPipelineLibrary = {
+        "supportsGraphicsPipelineLibrary", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_graphics_pipeline_library extension", &members,
+        "https://anglebug.com/7369"};
+
+    FeatureInfo supportsPipelineProtectedAccess = {
+        "supportsPipelineProtectedAccess", FeatureCategory::VulkanFeatures,
+        "VkDevice supports the VK_EXT_pipeline_protected_access extension", &members,
+        "https://anglebug.com/7714"};
+
+    FeatureInfo preferSubmitOnAnySamplesPassedQueryEnd = {
+        "preferSubmitOnAnySamplesPassedQueryEnd", FeatureCategory::VulkanWorkarounds,
+        "Submit commands to driver when last GL_ANY_SAMPLES_PASSED query is made for performance "
+        "improvements.",
+        &members, "https://issuetracker.google.com/250706693"};
+};
+
+inline FeaturesVk::FeaturesVk()  = default;
+inline FeaturesVk::~FeaturesVk() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_FEATURESVK_H_
diff --git a/gfx/angle/checkout/include/platform/FrontendFeatures_autogen.h b/gfx/angle/checkout/include/platform/FrontendFeatures_autogen.h
new file mode 100644
index 0000000000..4cb5fa8afa
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/FrontendFeatures_autogen.h
@@ -0,0 +1,115 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_features.py using data from frontend_features.json.
+//
+// Copyright 2022 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.
+//
+// FrontendFeatures_autogen.h: Features/workarounds for driver bugs and other behaviors seen
+// on all platforms.
+
+#ifndef ANGLE_PLATFORM_FRONTENDFEATURES_H_
+#define ANGLE_PLATFORM_FRONTENDFEATURES_H_
+
+#include "platform/Feature.h"
+
+namespace angle
+{
+
+struct FrontendFeatures : FeatureSetBase
+{
+    FrontendFeatures();
+    ~FrontendFeatures();
+
+    FeatureInfo loseContextOnOutOfMemory = {
+        "loseContextOnOutOfMemory",
+        FeatureCategory::FrontendWorkarounds,
+        "Some users rely on a lost context notification if a GL_OUT_OF_MEMORY error occurs",
+        &members,
+    };
+
+    FeatureInfo disableProgramCachingForTransformFeedback = {
+        "disableProgramCachingForTransformFeedback",
+        FeatureCategory::FrontendWorkarounds,
+        "On some GPUs, program binaries don't contain transform feedback varyings",
+        &members,
+    };
+
+    FeatureInfo scalarizeVecAndMatConstructorArgs = {
+        "scalarizeVecAndMatConstructorArgs", FeatureCategory::FrontendWorkarounds,
+        "Always rewrite vec/mat constructors to be consistent", &members,
+        "http://crbug.com/1165751"};
+
+    FeatureInfo disableProgramBinary = {"disableProgramBinary", FeatureCategory::FrontendFeatures,
+                                        "Disable support for GL_OES_get_program_binary", &members,
+                                        "http://anglebug.com/5007"};
+
+    FeatureInfo disableDrawBuffersIndexed = {
+        "disableDrawBuffersIndexed", FeatureCategory::FrontendFeatures,
+        "Disable support for OES_draw_buffers_indexed and EXT_draw_buffers_indexed", &members,
+        "http://anglebug.com/7724"};
+
+    FeatureInfo disableAnisotropicFiltering = {
+        "disableAnisotropicFiltering",
+        FeatureCategory::FrontendWorkarounds,
+        "Disable support for anisotropic filtering",
+        &members,
+    };
+
+    FeatureInfo allowCompressedFormats = {
+        "allowCompressedFormats",
+        FeatureCategory::FrontendWorkarounds,
+        "Allow compressed formats",
+        &members,
+    };
+
+    FeatureInfo forceDepthAttachmentInitOnClear = {
+        "forceDepthAttachmentInitOnClear", FeatureCategory::FrontendWorkarounds,
+        "Force depth attachment initialization on clear ops", &members,
+        "https://anglebug.com/7246"};
+
+    FeatureInfo enableCaptureLimits = {"enableCaptureLimits", FeatureCategory::FrontendFeatures,
+                                       "Set the context limits like frame capturing was enabled",
+                                       &members, "http://anglebug.com/5750"};
+
+    FeatureInfo enableCompressingPipelineCacheInThreadPool = {
+        "enableCompressingPipelineCacheInThreadPool", FeatureCategory::FrontendWorkarounds,
+        "Enable compressing pipeline cache in thread pool.", &members, "http://anglebug.com/4722"};
+
+    FeatureInfo forceRobustResourceInit = {
+        "forceRobustResourceInit", FeatureCategory::FrontendFeatures,
+        "Force-enable robust resource init", &members, "http://anglebug.com/6041"};
+
+    FeatureInfo forceInitShaderVariables = {
+        "forceInitShaderVariables",
+        FeatureCategory::FrontendFeatures,
+        "Force-enable shader variable initialization",
+        &members,
+    };
+
+    FeatureInfo enableProgramBinaryForCapture = {
+        "enableProgramBinaryForCapture", FeatureCategory::FrontendFeatures,
+        "Even if FrameCapture is enabled, enable GL_OES_get_program_binary", &members,
+        "http://anglebug.com/5658"};
+
+    FeatureInfo forceGlErrorChecking = {
+        "forceGlErrorChecking", FeatureCategory::FrontendFeatures,
+        "Force GL error checking (i.e. prevent applications from disabling error checking",
+        &members, "https://issuetracker.google.com/220069903"};
+
+    FeatureInfo emulatePixelLocalStorage = {
+        "emulatePixelLocalStorage", FeatureCategory::FrontendFeatures,
+        "Emulate ANGLE_shader_pixel_local_storage using shader images", &members,
+        "http://anglebug.com/7279"};
+
+    FeatureInfo cacheCompiledShader = {"cacheCompiledShader", FeatureCategory::FrontendFeatures,
+                                       "Enable to cache compiled shaders", &members,
+                                       "http://anglebug.com/7036"};
+};
+
+inline FrontendFeatures::FrontendFeatures()  = default;
+inline FrontendFeatures::~FrontendFeatures() = default;
+
+}  // namespace angle
+
+#endif  // ANGLE_PLATFORM_FRONTENDFEATURES_H_
diff --git a/gfx/angle/checkout/include/platform/PlatformMethods.h b/gfx/angle/checkout/include/platform/PlatformMethods.h
new file mode 100644
index 0000000000..48ef335796
--- /dev/null
+++ b/gfx/angle/checkout/include/platform/PlatformMethods.h
@@ -0,0 +1,334 @@
+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// PlatformMethods.h: The public interface ANGLE exposes to the API layer, for
+//   doing platform-specific tasks like gathering data, or for tracing.
+
+#ifndef ANGLE_PLATFORMMETHODS_H
+#define ANGLE_PLATFORMMETHODS_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <array>
+
+#define EGL_PLATFORM_ANGLE_PLATFORM_METHODS_ANGLEX 0x6AFB
+
+#if !defined(ANGLE_PLATFORM_EXPORT)
+#    if defined(_WIN32)
+#        if !defined(LIBANGLE_IMPLEMENTATION)
+#            define ANGLE_PLATFORM_EXPORT __declspec(dllimport)
+#        else
+#            define ANGLE_PLATFORM_EXPORT __declspec(dllexport)
+#        endif
+#    elif defined(__GNUC__) || defined(__clang__)
+#        define ANGLE_PLATFORM_EXPORT __attribute__((visibility("default")))
+#    endif
+#endif
+#if !defined(ANGLE_PLATFORM_EXPORT)
+#    define ANGLE_PLATFORM_EXPORT
+#endif
+
+#if defined(_WIN32)
+#    define ANGLE_APIENTRY __stdcall
+#else
+#    define ANGLE_APIENTRY
+#endif
+
+namespace angle
+{
+struct FeaturesD3D;
+struct FeaturesVk;
+struct FeaturesMtl;
+using TraceEventHandle = uint64_t;
+using EGLDisplayType   = void *;
+struct PlatformMethods;
+
+// Use a C-like API to not trigger undefined calling behaviour.
+// Avoid using decltype here to work around sanitizer limitations.
+// TODO(jmadill): Use decltype here if/when UBSAN is fixed.
+
+// System --------------------------------------------------------------
+
+// Wall clock time in seconds since the epoch.
+// TODO(jmadill): investigate using an ANGLE internal time library
+using CurrentTimeFunc = double (*)(PlatformMethods *platform);
+inline double DefaultCurrentTime(PlatformMethods *platform)
+{
+    return 0.0;
+}
+
+// Monotonically increasing time in seconds from an arbitrary fixed point in the past.
+// This function is expected to return at least millisecond-precision values. For this reason,
+// it is recommended that the fixed point be no further in the past than the epoch.
+using MonotonicallyIncreasingTimeFunc = double (*)(PlatformMethods *platform);
+inline double DefaultMonotonicallyIncreasingTime(PlatformMethods *platform)
+{
+    return 0.0;
+}
+
+// Logging ------------------------------------------------------------
+
+// Log an error message within the platform implementation.
+using LogErrorFunc = void (*)(PlatformMethods *platform, const char *errorMessage);
+inline void DefaultLogError(PlatformMethods *platform, const char *errorMessage) {}
+
+// Log a warning message within the platform implementation.
+using LogWarningFunc = void (*)(PlatformMethods *platform, const char *warningMessage);
+inline void DefaultLogWarning(PlatformMethods *platform, const char *warningMessage) {}
+
+// Log an info message within the platform implementation.
+using LogInfoFunc = void (*)(PlatformMethods *platform, const char *infoMessage);
+inline void DefaultLogInfo(PlatformMethods *platform, const char *infoMessage) {}
+
+// Tracing --------
+
+// Get a pointer to the enabled state of the given trace category. The
+// embedder can dynamically change the enabled state as trace event
+// recording is started and stopped by the application. Only long-lived
+// literal strings should be given as the category name. The implementation
+// expects the returned pointer to be held permanently in a local static. If
+// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
+// addTraceEvent is expected to be called by the trace event macros.
+using GetTraceCategoryEnabledFlagFunc = const unsigned char *(*)(PlatformMethods *platform,
+                                                                 const char *categoryName);
+inline const unsigned char *DefaultGetTraceCategoryEnabledFlag(PlatformMethods *platform,
+                                                               const char *categoryName)
+{
+    return nullptr;
+}
+
+//
+// Add a trace event to the platform tracing system. Depending on the actual
+// enabled state, this event may be recorded or dropped.
+// - phase specifies the type of event:
+//   - BEGIN ('B'): Marks the beginning of a scoped event.
+//   - END ('E'): Marks the end of a scoped event.
+//   - COMPLETE ('X'): Marks the beginning of a scoped event, but doesn't
+//     need a matching END event. Instead, at the end of the scope,
+//     updateTraceEventDuration() must be called with the TraceEventHandle
+//     returned from addTraceEvent().
+//   - INSTANT ('I'): Standalone, instantaneous event.
+//   - START ('S'): Marks the beginning of an asynchronous event (the end
+//     event can occur in a different scope or thread). The id parameter is
+//     used to match START/FINISH pairs.
+//   - FINISH ('F'): Marks the end of an asynchronous event.
+//   - COUNTER ('C'): Used to trace integer quantities that change over
+//     time. The argument values are expected to be of type int.
+//   - METADATA ('M'): Reserved for internal use.
+// - categoryEnabled is the pointer returned by getTraceCategoryEnabledFlag.
+// - name is the name of the event. Also used to match BEGIN/END and
+//   START/FINISH pairs.
+// - id optionally allows events of the same name to be distinguished from
+//   each other. For example, to trace the construction and destruction of
+//   objects, specify the pointer as the id parameter.
+// - timestamp should be a time value returned from monotonicallyIncreasingTime.
+// - numArgs specifies the number of elements in argNames, argTypes, and
+//   argValues.
+// - argNames is the array of argument names. Use long-lived literal strings
+//   or specify the COPY flag.
+// - argTypes is the array of argument types:
+//   - BOOL (1): bool
+//   - UINT (2): unsigned long long
+//   - INT (3): long long
+//   - DOUBLE (4): double
+//   - POINTER (5): void*
+//   - STRING (6): char* (long-lived null-terminated char* string)
+//   - COPY_STRING (7): char* (temporary null-terminated char* string)
+//   - CONVERTABLE (8): WebConvertableToTraceFormat
+// - argValues is the array of argument values. Each value is the unsigned
+//   long long member of a union of all supported types.
+// - flags can be 0 or one or more of the following, ORed together:
+//   - COPY (0x1): treat all strings (name, argNames and argValues of type
+//     string) as temporary so that they will be copied by addTraceEvent.
+//   - HAS_ID (0x2): use the id argument to uniquely identify the event for
+//     matching with other events of the same name.
+//   - MANGLE_ID (0x4): specify this flag if the id parameter is the value
+//     of a pointer.
+using AddTraceEventFunc = angle::TraceEventHandle (*)(PlatformMethods *platform,
+                                                      char phase,
+                                                      const unsigned char *categoryEnabledFlag,
+                                                      const char *name,
+                                                      unsigned long long id,
+                                                      double timestamp,
+                                                      int numArgs,
+                                                      const char **argNames,
+                                                      const unsigned char *argTypes,
+                                                      const unsigned long long *argValues,
+                                                      unsigned char flags);
+inline angle::TraceEventHandle DefaultAddTraceEvent(PlatformMethods *platform,
+                                                    char phase,
+                                                    const unsigned char *categoryEnabledFlag,
+                                                    const char *name,
+                                                    unsigned long long id,
+                                                    double timestamp,
+                                                    int numArgs,
+                                                    const char **argNames,
+                                                    const unsigned char *argTypes,
+                                                    const unsigned long long *argValues,
+                                                    unsigned char flags)
+{
+    return 0;
+}
+
+// Set the duration field of a COMPLETE trace event.
+using UpdateTraceEventDurationFunc = void (*)(PlatformMethods *platform,
+                                              const unsigned char *categoryEnabledFlag,
+                                              const char *name,
+                                              angle::TraceEventHandle eventHandle);
+inline void DefaultUpdateTraceEventDuration(PlatformMethods *platform,
+                                            const unsigned char *categoryEnabledFlag,
+                                            const char *name,
+                                            angle::TraceEventHandle eventHandle)
+{}
+
+// Callbacks for reporting histogram data.
+// CustomCounts histogram has exponential bucket sizes, so that min=1, max=1000000, bucketCount=50
+// would do.
+using HistogramCustomCountsFunc = void (*)(PlatformMethods *platform,
+                                           const char *name,
+                                           int sample,
+                                           int min,
+                                           int max,
+                                           int bucketCount);
+inline void DefaultHistogramCustomCounts(PlatformMethods *platform,
+                                         const char *name,
+                                         int sample,
+                                         int min,
+                                         int max,
+                                         int bucketCount)
+{}
+// Enumeration histogram buckets are linear, boundaryValue should be larger than any possible sample
+// value.
+using HistogramEnumerationFunc = void (*)(PlatformMethods *platform,
+                                          const char *name,
+                                          int sample,
+                                          int boundaryValue);
+inline void DefaultHistogramEnumeration(PlatformMethods *platform,
+                                        const char *name,
+                                        int sample,
+                                        int boundaryValue)
+{}
+// Unlike enumeration histograms, sparse histograms only allocate memory for non-empty buckets.
+using HistogramSparseFunc = void (*)(PlatformMethods *platform, const char *name, int sample);
+inline void DefaultHistogramSparse(PlatformMethods *platform, const char *name, int sample) {}
+// Boolean histograms track two-state variables.
+using HistogramBooleanFunc = void (*)(PlatformMethods *platform, const char *name, bool sample);
+inline void DefaultHistogramBoolean(PlatformMethods *platform, const char *name, bool sample) {}
+
+// Callback on a successful program link with the program binary. Can be used to store
+// shaders to disk. Keys are a 160-bit SHA-1 hash.
+using ProgramKeyType   = std::array<uint8_t, 20>;
+using CacheProgramFunc = void (*)(PlatformMethods *platform,
+                                  const ProgramKeyType &key,
+                                  size_t programSize,
+                                  const uint8_t *programBytes);
+inline void DefaultCacheProgram(PlatformMethods *platform,
+                                const ProgramKeyType &key,
+                                size_t programSize,
+                                const uint8_t *programBytes)
+{}
+
+using PostWorkerTaskCallback                       = void (*)(void *userData);
+using PostWorkerTaskFunc                           = void (*)(PlatformMethods *platform,
+                                    PostWorkerTaskCallback callback,
+                                    void *userData);
+constexpr PostWorkerTaskFunc DefaultPostWorkerTask = nullptr;
+
+// Placeholder values where feature override callbacks used to be.  They are deprecated in favor of
+// EGL_ANGLE_feature_control.  The placeholders are there to keep the layout of the PlatformMethods
+// constant to support drop-in replacement of ANGLE's .so files in applications built with an older
+// header.
+using PlaceholderCallbackFunc = void (*)(...);
+inline void DefaultPlaceholderCallback(...) {}
+
+// Platform methods are enumerated here once.
+#define ANGLE_PLATFORM_OP(OP)                                    \
+    OP(currentTime, CurrentTime)                                 \
+    OP(monotonicallyIncreasingTime, MonotonicallyIncreasingTime) \
+    OP(logError, LogError)                                       \
+    OP(logWarning, LogWarning)                                   \
+    OP(logInfo, LogInfo)                                         \
+    OP(getTraceCategoryEnabledFlag, GetTraceCategoryEnabledFlag) \
+    OP(addTraceEvent, AddTraceEvent)                             \
+    OP(updateTraceEventDuration, UpdateTraceEventDuration)       \
+    OP(histogramCustomCounts, HistogramCustomCounts)             \
+    OP(histogramEnumeration, HistogramEnumeration)               \
+    OP(histogramSparse, HistogramSparse)                         \
+    OP(histogramBoolean, HistogramBoolean)                       \
+    OP(placeholder1, PlaceholderCallback)                        \
+    OP(placeholder2, PlaceholderCallback)                        \
+    OP(cacheProgram, CacheProgram)                               \
+    OP(placeholder3, PlaceholderCallback)                        \
+    OP(postWorkerTask, PostWorkerTask)
+
+#define ANGLE_PLATFORM_METHOD_DEF(Name, CapsName) CapsName##Func Name = Default##CapsName;
+
+struct ANGLE_PLATFORM_EXPORT PlatformMethods
+{
+    inline PlatformMethods();
+
+    // User data pointer for any implementation specific members. Put it at the start of the
+    // platform structure so it doesn't become overwritten if one version of the platform
+    // adds or removes new members.
+    void *context = 0;
+
+    ANGLE_PLATFORM_OP(ANGLE_PLATFORM_METHOD_DEF)
+};
+
+inline PlatformMethods::PlatformMethods() = default;
+
+#undef ANGLE_PLATFORM_METHOD_DEF
+
+// Subtract one to account for the context pointer.
+constexpr unsigned int g_NumPlatformMethods = (sizeof(PlatformMethods) / sizeof(uintptr_t)) - 1;
+
+// No further uses of platform methods is allowed.  EGL extensions should be used instead.  While
+// methods are being removed, use PlaceholderCallback to keep the layout of PlatformMethods
+// constant.
+static_assert(g_NumPlatformMethods == 17, "Avoid adding methods to PlatformMethods");
+
+#define ANGLE_PLATFORM_METHOD_STRING(Name) #Name
+#define ANGLE_PLATFORM_METHOD_STRING2(Name, CapsName) ANGLE_PLATFORM_METHOD_STRING(Name),
+
+constexpr const char *const g_PlatformMethodNames[g_NumPlatformMethods] = {
+    ANGLE_PLATFORM_OP(ANGLE_PLATFORM_METHOD_STRING2)};
+
+#undef ANGLE_PLATFORM_METHOD_STRING2
+#undef ANGLE_PLATFORM_METHOD_STRING
+
+}  // namespace angle
+
+extern "C" {
+
+// Gets the platform methods on the passed-in EGL display. If the method name signature does not
+// match the compiled signature for this ANGLE, false is returned. On success true is returned.
+// The application should set any platform methods it cares about on the returned pointer.
+// If display is not valid, behaviour is undefined.
+
+ANGLE_PLATFORM_EXPORT bool ANGLE_APIENTRY ANGLEGetDisplayPlatform(angle::EGLDisplayType display,
+                                                                  const char *const methodNames[],
+                                                                  unsigned int methodNameCount,
+                                                                  void *context,
+                                                                  void *platformMethodsOut);
+
+// Sets the platform methods back to their defaults.
+// If display is not valid, behaviour is undefined.
+ANGLE_PLATFORM_EXPORT void ANGLE_APIENTRY ANGLEResetDisplayPlatform(angle::EGLDisplayType display);
+}  // extern "C"
+
+namespace angle
+{
+typedef bool(ANGLE_APIENTRY *GetDisplayPlatformFunc)(angle::EGLDisplayType,
+                                                     const char *const *,
+                                                     unsigned int,
+                                                     void *,
+                                                     void *);
+typedef void(ANGLE_APIENTRY *ResetDisplayPlatformFunc)(angle::EGLDisplayType);
+}  // namespace angle
+
+// This function is not exported
+angle::PlatformMethods *ANGLEPlatformCurrent();
+
+#endif  // ANGLE_PLATFORMMETHODS_H