diff --git a/CMakeLists.txt b/CMakeLists.txt
index ad25ae0..62d3a93 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -174,6 +174,7 @@
 set_if_not_defined(DAWN_ABSEIL_DIR "${DAWN_THIRD_PARTY_DIR}/abseil-cpp" "Directory in which to find Abseil")
 set_if_not_defined(DAWN_GLFW_DIR "${DAWN_THIRD_PARTY_DIR}/glfw" "Directory in which to find GLFW")
 set_if_not_defined(DAWN_JINJA2_DIR "${DAWN_THIRD_PARTY_DIR}/jinja2" "Directory in which to find Jinja2")
+set_if_not_defined(DAWN_KHRONOS_DIR "${DAWN_THIRD_PARTY_DIR}/khronos" "Directory in which to find Khronos GL headers")
 set_if_not_defined(DAWN_SPIRV_HEADERS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-headers/src" "Directory in which to find SPIRV-Headers")
 set_if_not_defined(DAWN_SPIRV_TOOLS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-tools/src" "Directory in which to find SPIRV-Tools")
 set_if_not_defined(DAWN_SWIFTSHADER_DIR "${DAWN_THIRD_PARTY_DIR}/swiftshader" "Directory in which to find swiftshader")
diff --git a/include/dawn/native/OpenGLBackend.h b/include/dawn/native/OpenGLBackend.h
index bee9dae..cceaab8 100644
--- a/include/dawn/native/OpenGLBackend.h
+++ b/include/dawn/native/OpenGLBackend.h
@@ -23,15 +23,14 @@
 namespace dawn::native::opengl {
 
 struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptions : public AdapterDiscoveryOptionsBase {
-    AdapterDiscoveryOptions();
+    explicit AdapterDiscoveryOptions(WGPUBackendType type);
 
     void* (*getProc)(const char*);
 };
 
-struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptionsES : public AdapterDiscoveryOptionsBase {
+// TODO(crbug.com/dawn/810): This struct can be removed once Chrome is no longer using it.
+struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptionsES : public AdapterDiscoveryOptions {
     AdapterDiscoveryOptionsES();
-
-    void* (*getProc)(const char*);
 };
 
 using PresentCallback = void (*)(void*);
diff --git a/src/dawn/native/BUILD.gn b/src/dawn/native/BUILD.gn
index 137ce1b..8f9f059 100644
--- a/src/dawn/native/BUILD.gn
+++ b/src/dawn/native/BUILD.gn
@@ -540,8 +540,12 @@
       "opengl/CommandBufferGL.h",
       "opengl/ComputePipelineGL.cpp",
       "opengl/ComputePipelineGL.h",
+      "opengl/ContextEGL.cpp",
+      "opengl/ContextEGL.h",
       "opengl/DeviceGL.cpp",
       "opengl/DeviceGL.h",
+      "opengl/EGLFunctions.cpp",
+      "opengl/EGLFunctions.h",
       "opengl/Forward.h",
       "opengl/GLFormat.cpp",
       "opengl/GLFormat.h",
@@ -575,6 +579,7 @@
       "opengl/UtilsGL.h",
       "opengl/opengl_platform.h",
     ]
+    include_dirs = [ "//third_party/khronos" ]
   }
 
   if (dawn_enable_vulkan) {
diff --git a/src/dawn/native/CMakeLists.txt b/src/dawn/native/CMakeLists.txt
index 8542b33..a523393 100644
--- a/src/dawn/native/CMakeLists.txt
+++ b/src/dawn/native/CMakeLists.txt
@@ -418,8 +418,12 @@
         "opengl/CommandBufferGL.h"
         "opengl/ComputePipelineGL.cpp"
         "opengl/ComputePipelineGL.h"
+        "opengl/ContextEGL.cpp"
+        "opengl/ContextEGL.h"
         "opengl/DeviceGL.cpp"
         "opengl/DeviceGL.h"
+        "opengl/EGLFunctions.cpp"
+        "opengl/EGLFunctions.h"
         "opengl/Forward.h"
         "opengl/GLFormat.cpp"
         "opengl/GLFormat.h"
@@ -454,6 +458,7 @@
         "opengl/opengl_platform.h"
     )
 
+    target_include_directories(dawn_native PRIVATE ${DAWN_KHRONOS_DIR})
     target_link_libraries(dawn_native PRIVATE dawn_khronos_platform)
 endif()
 
diff --git a/src/dawn/native/opengl/AdapterGL.cpp b/src/dawn/native/opengl/AdapterGL.cpp
index eca46c1..9f9d4ba 100644
--- a/src/dawn/native/opengl/AdapterGL.cpp
+++ b/src/dawn/native/opengl/AdapterGL.cpp
@@ -14,11 +14,13 @@
 
 #include "dawn/native/opengl/AdapterGL.h"
 
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "dawn/common/GPUInfo.h"
-#include "dawn/common/Log.h"
 #include "dawn/native/Instance.h"
+#include "dawn/native/opengl/ContextEGL.h"
 #include "dawn/native/opengl/DeviceGL.h"
 
 namespace dawn::native::opengl {
@@ -49,69 +51,6 @@
     return vendorId;
 }
 
-void KHRONOS_APIENTRY OnGLDebugMessage(GLenum source,
-                                       GLenum type,
-                                       GLuint id,
-                                       GLenum severity,
-                                       GLsizei length,
-                                       const GLchar* message,
-                                       const void* userParam) {
-    const char* sourceText;
-    switch (source) {
-        case GL_DEBUG_SOURCE_API:
-            sourceText = "OpenGL";
-            break;
-        case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
-            sourceText = "Window System";
-            break;
-        case GL_DEBUG_SOURCE_SHADER_COMPILER:
-            sourceText = "Shader Compiler";
-            break;
-        case GL_DEBUG_SOURCE_THIRD_PARTY:
-            sourceText = "Third Party";
-            break;
-        case GL_DEBUG_SOURCE_APPLICATION:
-            sourceText = "Application";
-            break;
-        case GL_DEBUG_SOURCE_OTHER:
-            sourceText = "Other";
-            break;
-        default:
-            sourceText = "UNKNOWN";
-            break;
-    }
-
-    const char* severityText;
-    switch (severity) {
-        case GL_DEBUG_SEVERITY_HIGH:
-            severityText = "High";
-            break;
-        case GL_DEBUG_SEVERITY_MEDIUM:
-            severityText = "Medium";
-            break;
-        case GL_DEBUG_SEVERITY_LOW:
-            severityText = "Low";
-            break;
-        case GL_DEBUG_SEVERITY_NOTIFICATION:
-            severityText = "Notification";
-            break;
-        default:
-            severityText = "UNKNOWN";
-            break;
-    }
-
-    if (type == GL_DEBUG_TYPE_ERROR) {
-        dawn::WarningLog() << "OpenGL error:"
-                           << "\n    Source: " << sourceText      //
-                           << "\n    ID: " << id                  //
-                           << "\n    Severity: " << severityText  //
-                           << "\n    Message: " << message;
-
-        // Abort on an error when in Debug mode.
-        UNREACHABLE();
-    }
-}
-
 }  // anonymous namespace
 
 Adapter::Adapter(InstanceBase* instance, wgpu::BackendType backendType)
@@ -119,6 +58,7 @@
 
 MaybeError Adapter::InitializeGLFunctions(void* (*getProc)(const char*)) {
     // Use getProc to populate the dispatch table
+    mEGLFunctions.Init(getProc);
     return mFunctions.Initialize(getProc);
 }
 
@@ -134,47 +74,6 @@
         ASSERT(GetBackendType() == wgpu::BackendType::OpenGL);
     }
 
-    // Use the debug output functionality to get notified about GL errors
-    // TODO(cwallez@chromium.org): add support for the KHR_debug and ARB_debug_output
-    // extensions
-    bool hasDebugOutput = mFunctions.IsAtLeastGL(4, 3) || mFunctions.IsAtLeastGLES(3, 2);
-
-    if (GetInstance()->IsBackendValidationEnabled() && hasDebugOutput) {
-        mFunctions.Enable(GL_DEBUG_OUTPUT);
-        mFunctions.Enable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-
-        // Any GL error; dangerous undefined behavior; any shader compiler and linker errors
-        mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0,
-                                       nullptr, GL_TRUE);
-
-        // Severe performance warnings; GLSL or other shader compiler and linker warnings;
-        // use of currently deprecated behavior
-        mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0,
-                                       nullptr, GL_TRUE);
-
-        // Performance warnings from redundant state changes; trivial undefined behavior
-        // This is disabled because we do an incredible amount of redundant state changes.
-        mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0,
-                                       nullptr, GL_FALSE);
-
-        // Any message which is not an error or performance concern
-        mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION,
-                                       0, nullptr, GL_FALSE);
-        mFunctions.DebugMessageCallback(&OnGLDebugMessage, nullptr);
-    }
-
-    // Set state that never changes between devices.
-    mFunctions.Enable(GL_DEPTH_TEST);
-    mFunctions.Enable(GL_SCISSOR_TEST);
-    mFunctions.Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
-    if (mFunctions.GetVersion().IsDesktop()) {
-        // These are not necessary on GLES. The functionality is enabled by default, and
-        // works by specifying sample counts and SRGB textures, respectively.
-        mFunctions.Enable(GL_MULTISAMPLE);
-        mFunctions.Enable(GL_FRAMEBUFFER_SRGB);
-    }
-    mFunctions.Enable(GL_SAMPLE_MASK);
-
     mName = reinterpret_cast<const char*>(mFunctions.GetString(GL_RENDERER));
 
     // Workaroud to find vendor id from vendor name
@@ -251,9 +150,12 @@
 }
 
 ResultOrError<Ref<DeviceBase>> Adapter::CreateDeviceImpl(const DeviceDescriptor* descriptor) {
-    // There is no limit on the number of devices created from this adapter because they can
-    // all share the same backing OpenGL context.
-    return Device::Create(this, descriptor, mFunctions);
+    EGLenum api =
+        GetBackendType() == wgpu::BackendType::OpenGL ? EGL_OPENGL_API : EGL_OPENGL_ES_API;
+
+    std::unique_ptr<Device::Context> context = ContextEGL::Create(mEGLFunctions, api);
+
+    return Device::Create(this, descriptor, mFunctions, std::move(context));
 }
 
 }  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/AdapterGL.h b/src/dawn/native/opengl/AdapterGL.h
index 4101887..6e354b2 100644
--- a/src/dawn/native/opengl/AdapterGL.h
+++ b/src/dawn/native/opengl/AdapterGL.h
@@ -16,6 +16,7 @@
 #define SRC_DAWN_NATIVE_OPENGL_ADAPTERGL_H_
 
 #include "dawn/native/Adapter.h"
+#include "dawn/native/opengl/EGLFunctions.h"
 #include "dawn/native/opengl/OpenGLFunctions.h"
 
 namespace dawn::native::opengl {
@@ -38,6 +39,7 @@
     ResultOrError<Ref<DeviceBase>> CreateDeviceImpl(const DeviceDescriptor* descriptor) override;
 
     OpenGLFunctions mFunctions;
+    EGLFunctions mEGLFunctions;
 };
 
 }  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/BackendGL.cpp b/src/dawn/native/opengl/BackendGL.cpp
index c4b8776..3fad08f 100644
--- a/src/dawn/native/opengl/BackendGL.cpp
+++ b/src/dawn/native/opengl/BackendGL.cpp
@@ -14,10 +14,17 @@
 
 #include "dawn/native/opengl/BackendGL.h"
 
+#include <EGL/egl.h>
+
+#include <memory>
 #include <utility>
 
+#include "dawn/common/SystemUtils.h"
+#include "dawn/native/Instance.h"
 #include "dawn/native/OpenGLBackend.h"
 #include "dawn/native/opengl/AdapterGL.h"
+#include "dawn/native/opengl/ContextEGL.h"
+#include "dawn/native/opengl/EGLFunctions.h"
 
 namespace dawn::native::opengl {
 
@@ -27,8 +34,53 @@
     : BackendConnection(instance, backendType) {}
 
 std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
-    // The OpenGL backend needs at least "getProcAddress" to discover an adapter.
-    return {};
+    std::vector<Ref<AdapterBase>> adapters;
+#if DAWN_PLATFORM_IS(WINDOWS)
+    const char* eglLib = "libEGL.dll";
+#elif DAWN_PLATFORM_IS(MACOS)
+    const char* eglLib = "libEGL.dylib";
+#else
+    const char* eglLib = "libEGL.so";
+#endif
+    if (!mLibEGL.Valid() && !mLibEGL.Open(eglLib)) {
+        return {};
+    }
+
+    AdapterDiscoveryOptions options(ToAPI(GetType()));
+    options.getProc =
+        reinterpret_cast<void* (*)(const char*)>(mLibEGL.GetProc("eglGetProcAddress"));
+    if (!options.getProc) {
+        return {};
+    }
+
+    EGLFunctions egl;
+    egl.Init(options.getProc);
+
+    EGLenum api = GetType() == wgpu::BackendType::OpenGLES ? EGL_OPENGL_ES_API : EGL_OPENGL_API;
+    std::unique_ptr<Device::Context> context = ContextEGL::Create(egl, api);
+    if (!context) {
+        return {};
+    }
+
+    EGLDisplay prevDisplay = egl.GetCurrentDisplay();
+    EGLContext prevDrawSurface = egl.GetCurrentSurface(EGL_DRAW);
+    EGLContext prevReadSurface = egl.GetCurrentSurface(EGL_READ);
+    EGLContext prevContext = egl.GetCurrentContext();
+
+    context->MakeCurrent();
+
+    auto result = DiscoverAdapters(&options);
+
+    if (result.IsError()) {
+        GetInstance()->ConsumedError(result.AcquireError());
+    } else {
+        auto value = result.AcquireSuccess();
+        adapters.insert(adapters.end(), value.begin(), value.end());
+    }
+
+    egl.MakeCurrent(prevDisplay, prevDrawSurface, prevReadSurface, prevContext);
+
+    return adapters;
 }
 
 ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
diff --git a/src/dawn/native/opengl/BackendGL.h b/src/dawn/native/opengl/BackendGL.h
index 5916728..dc8fea5 100644
--- a/src/dawn/native/opengl/BackendGL.h
+++ b/src/dawn/native/opengl/BackendGL.h
@@ -17,6 +17,7 @@
 
 #include <vector>
 
+#include "dawn/common/DynamicLib.h"
 #include "dawn/native/BackendConnection.h"
 
 namespace dawn::native::opengl {
@@ -31,6 +32,7 @@
 
   private:
     bool mCreatedAdapter = false;
+    DynamicLib mLibEGL;
 };
 
 }  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/ContextEGL.cpp b/src/dawn/native/opengl/ContextEGL.cpp
new file mode 100644
index 0000000..795b3c0
--- /dev/null
+++ b/src/dawn/native/opengl/ContextEGL.cpp
@@ -0,0 +1,78 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dawn/native/opengl/ContextEGL.h"
+
+#include <memory>
+#include <vector>
+
+namespace dawn::native::opengl {
+
+std::unique_ptr<ContextEGL> ContextEGL::Create(const EGLFunctions& egl, EGLenum api) {
+    EGLDisplay display = egl.GetCurrentDisplay();
+
+    if (display == EGL_NO_DISPLAY) {
+        display = egl.GetDisplay(EGL_DEFAULT_DISPLAY);
+    }
+
+    if (display == EGL_NO_DISPLAY) {
+        return nullptr;
+    }
+
+    EGLint renderableType = api == EGL_OPENGL_ES_API ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_BIT;
+
+    egl.Initialize(display, nullptr, nullptr);
+
+    // Since we're creating a surfaceless context, the only thing we really care
+    // about is the RENDERABLE_TYPE.
+    EGLint config_attribs[] = {EGL_RENDERABLE_TYPE, renderableType, EGL_NONE};
+
+    EGLint num_config;
+    EGLConfig config;
+    if (egl.ChooseConfig(display, config_attribs, &config, 1, &num_config) == EGL_FALSE) {
+        return nullptr;
+    }
+
+    if (!egl.BindAPI(api)) {
+        return nullptr;
+    }
+
+    EGLint major, minor;
+    if (api == EGL_OPENGL_ES_API) {
+        major = 3;
+        minor = 1;
+    } else {
+        major = 4;
+        minor = 4;
+    }
+    EGLint attrib_list[] = {
+        EGL_CONTEXT_MAJOR_VERSION, major, EGL_CONTEXT_MINOR_VERSION, minor, EGL_NONE, EGL_NONE,
+    };
+    EGLContext context = egl.CreateContext(display, config, EGL_NO_CONTEXT, attrib_list);
+    if (!context) {
+        return nullptr;
+    }
+
+    return std::unique_ptr<ContextEGL>(new ContextEGL(egl, display, context));
+}
+
+void ContextEGL::MakeCurrent() {
+    egl.MakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, mContext);
+}
+
+ContextEGL::~ContextEGL() {
+    egl.DestroyContext(mDisplay, mContext);
+}
+
+}  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/ContextEGL.h b/src/dawn/native/opengl/ContextEGL.h
new file mode 100644
index 0000000..df5a146
--- /dev/null
+++ b/src/dawn/native/opengl/ContextEGL.h
@@ -0,0 +1,44 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_
+#define SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_
+
+#include <EGL/egl.h>
+
+#include <memory>
+
+#include "dawn/native/opengl/DeviceGL.h"
+#include "dawn/native/opengl/EGLFunctions.h"
+
+namespace dawn::native::opengl {
+
+class ContextEGL : public Device::Context {
+  public:
+    static std::unique_ptr<ContextEGL> Create(const EGLFunctions& functions, EGLenum api);
+    void MakeCurrent() override;
+    ~ContextEGL() override;
+
+  private:
+    ContextEGL(const EGLFunctions& functions, EGLDisplay display, EGLContext context)
+        : egl(functions), mDisplay(display), mContext(context) {}
+
+    const EGLFunctions egl;
+    EGLDisplay mDisplay;
+    EGLContext mContext;
+};
+
+}  // namespace dawn::native::opengl
+
+#endif  // SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_
diff --git a/src/dawn/native/opengl/DeviceGL.cpp b/src/dawn/native/opengl/DeviceGL.cpp
index fbceac9..35ff4ef 100644
--- a/src/dawn/native/opengl/DeviceGL.cpp
+++ b/src/dawn/native/opengl/DeviceGL.cpp
@@ -14,9 +14,12 @@
 
 #include "dawn/native/opengl/DeviceGL.h"
 
+#include "dawn/common/Log.h"
+
 #include "dawn/native/BackendConnection.h"
 #include "dawn/native/BindGroupLayout.h"
 #include "dawn/native/ErrorData.h"
+#include "dawn/native/Instance.h"
 #include "dawn/native/StagingBuffer.h"
 #include "dawn/native/opengl/BindGroupGL.h"
 #include "dawn/native/opengl/BindGroupLayoutGL.h"
@@ -32,30 +35,141 @@
 #include "dawn/native/opengl/SwapChainGL.h"
 #include "dawn/native/opengl/TextureGL.h"
 
+namespace {
+
+void KHRONOS_APIENTRY OnGLDebugMessage(GLenum source,
+                                       GLenum type,
+                                       GLuint id,
+                                       GLenum severity,
+                                       GLsizei length,
+                                       const GLchar* message,
+                                       const void* userParam) {
+    const char* sourceText;
+    switch (source) {
+        case GL_DEBUG_SOURCE_API:
+            sourceText = "OpenGL";
+            break;
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
+            sourceText = "Window System";
+            break;
+        case GL_DEBUG_SOURCE_SHADER_COMPILER:
+            sourceText = "Shader Compiler";
+            break;
+        case GL_DEBUG_SOURCE_THIRD_PARTY:
+            sourceText = "Third Party";
+            break;
+        case GL_DEBUG_SOURCE_APPLICATION:
+            sourceText = "Application";
+            break;
+        case GL_DEBUG_SOURCE_OTHER:
+            sourceText = "Other";
+            break;
+        default:
+            sourceText = "UNKNOWN";
+            break;
+    }
+
+    const char* severityText;
+    switch (severity) {
+        case GL_DEBUG_SEVERITY_HIGH:
+            severityText = "High";
+            break;
+        case GL_DEBUG_SEVERITY_MEDIUM:
+            severityText = "Medium";
+            break;
+        case GL_DEBUG_SEVERITY_LOW:
+            severityText = "Low";
+            break;
+        case GL_DEBUG_SEVERITY_NOTIFICATION:
+            severityText = "Notification";
+            break;
+        default:
+            severityText = "UNKNOWN";
+            break;
+    }
+
+    if (type == GL_DEBUG_TYPE_ERROR) {
+        dawn::WarningLog() << "OpenGL error:"
+                           << "\n    Source: " << sourceText      //
+                           << "\n    ID: " << id                  //
+                           << "\n    Severity: " << severityText  //
+                           << "\n    Message: " << message;
+
+        // Abort on an error when in Debug mode.
+        UNREACHABLE();
+    }
+}
+
+}  // anonymous namespace
+
 namespace dawn::native::opengl {
 
 // static
 ResultOrError<Ref<Device>> Device::Create(AdapterBase* adapter,
                                           const DeviceDescriptor* descriptor,
-                                          const OpenGLFunctions& functions) {
-    Ref<Device> device = AcquireRef(new Device(adapter, descriptor, functions));
+                                          const OpenGLFunctions& functions,
+                                          std::unique_ptr<Context> context) {
+    Ref<Device> device = AcquireRef(new Device(adapter, descriptor, functions, std::move(context)));
     DAWN_TRY(device->Initialize(descriptor));
     return device;
 }
 
 Device::Device(AdapterBase* adapter,
                const DeviceDescriptor* descriptor,
-               const OpenGLFunctions& functions)
-    : DeviceBase(adapter, descriptor), mGL(functions) {}
+               const OpenGLFunctions& functions,
+               std::unique_ptr<Context> context)
+    : DeviceBase(adapter, descriptor), mGL(functions), mContext(std::move(context)) {}
 
 Device::~Device() {
     Destroy();
 }
 
 MaybeError Device::Initialize(const DeviceDescriptor* descriptor) {
+    const OpenGLFunctions& gl = GetGL();
     InitTogglesFromDriver();
     mFormatTable = BuildGLFormatTable(GetBGRAInternalFormat());
 
+    // Use the debug output functionality to get notified about GL errors
+    // TODO(crbug.com/dawn/1475): add support for the KHR_debug and ARB_debug_output
+    // extensions
+    bool hasDebugOutput = gl.IsAtLeastGL(4, 3) || gl.IsAtLeastGLES(3, 2);
+
+    if (GetAdapter()->GetInstance()->IsBackendValidationEnabled() && hasDebugOutput) {
+        gl.Enable(GL_DEBUG_OUTPUT);
+        gl.Enable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+
+        // Any GL error; dangerous undefined behavior; any shader compiler and linker errors
+        gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr,
+                               GL_TRUE);
+
+        // Severe performance warnings; GLSL or other shader compiler and linker warnings;
+        // use of currently deprecated behavior
+        gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr,
+                               GL_TRUE);
+
+        // Performance warnings from redundant state changes; trivial undefined behavior
+        // This is disabled because we do an incredible amount of redundant state changes.
+        gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0, nullptr,
+                               GL_FALSE);
+
+        // Any message which is not an error or performance concern
+        gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0,
+                               nullptr, GL_FALSE);
+        gl.DebugMessageCallback(&OnGLDebugMessage, nullptr);
+    }
+
+    // Set initial state.
+    gl.Enable(GL_DEPTH_TEST);
+    gl.Enable(GL_SCISSOR_TEST);
+    gl.Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
+    if (gl.GetVersion().IsDesktop()) {
+        // These are not necessary on GLES. The functionality is enabled by default, and
+        // works by specifying sample counts and SRGB textures, respectively.
+        gl.Enable(GL_MULTISAMPLE);
+        gl.Enable(GL_FRAMEBUFFER_SRGB);
+    }
+    gl.Enable(GL_SAMPLE_MASK);
+
     return DeviceBase::Initialize(AcquireRef(new Queue(this, &descriptor->defaultQueue)));
 }
 
@@ -340,6 +454,9 @@
 }
 
 const OpenGLFunctions& Device::GetGL() const {
+    if (mContext) {
+        mContext->MakeCurrent();
+    }
     return mGL;
 }
 
diff --git a/src/dawn/native/opengl/DeviceGL.h b/src/dawn/native/opengl/DeviceGL.h
index b80439f..78abf11 100644
--- a/src/dawn/native/opengl/DeviceGL.h
+++ b/src/dawn/native/opengl/DeviceGL.h
@@ -39,14 +39,17 @@
 
 class Device final : public DeviceBase {
   public:
+    class Context;
     static ResultOrError<Ref<Device>> Create(AdapterBase* adapter,
                                              const DeviceDescriptor* descriptor,
-                                             const OpenGLFunctions& functions);
+                                             const OpenGLFunctions& functions,
+                                             std::unique_ptr<Context> context);
     ~Device() override;
 
     MaybeError Initialize(const DeviceDescriptor* descriptor);
 
-    // Contains all the OpenGL entry points, glDoFoo is called via gl.DoFoo.
+    // Returns all the OpenGL entry points and ensures that the associated
+    // Context is current.
     const OpenGLFunctions& GetGL() const;
 
     const GLFormat& GetGLFormat(const Format& format);
@@ -80,10 +83,17 @@
 
     float GetTimestampPeriodInNS() const override;
 
+    class Context {
+      public:
+        virtual ~Context() {}
+        virtual void MakeCurrent() = 0;
+    };
+
   private:
     Device(AdapterBase* adapter,
            const DeviceDescriptor* descriptor,
-           const OpenGLFunctions& functions);
+           const OpenGLFunctions& functions,
+           std::unique_ptr<Context> context);
 
     ResultOrError<Ref<BindGroupBase>> CreateBindGroupImpl(
         const BindGroupDescriptor* descriptor) override;
@@ -126,6 +136,7 @@
     std::queue<std::pair<GLsync, ExecutionSerial>> mFencesInFlight;
 
     GLFormatTable mFormatTable;
+    std::unique_ptr<Context> mContext = nullptr;
 };
 
 }  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/EGLFunctions.cpp b/src/dawn/native/opengl/EGLFunctions.cpp
new file mode 100644
index 0000000..75fd25b
--- /dev/null
+++ b/src/dawn/native/opengl/EGLFunctions.cpp
@@ -0,0 +1,42 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dawn/native/opengl/EGLFunctions.h"
+
+namespace dawn::native::opengl {
+
+void EGLFunctions::Init(void* (*getProc)(const char*)) {
+    GetProcAddress = reinterpret_cast<PFNEGLGETPROCADDRESSPROC>(getProc);
+    BindAPI = reinterpret_cast<PFNEGLBINDAPIPROC>(GetProcAddress("eglBindAPI"));
+    ChooseConfig = reinterpret_cast<PFNEGLCHOOSECONFIGPROC>(GetProcAddress("eglChooseConfig"));
+    CreateContext = reinterpret_cast<PFNEGLCREATECONTEXTPROC>(GetProcAddress("eglCreateContext"));
+    CreatePbufferSurface =
+        reinterpret_cast<PFNEGLCREATEPBUFFERSURFACEPROC>(GetProcAddress("eglCreatePbufferSurface"));
+    CreatePlatformWindowSurface = reinterpret_cast<PFNEGLCREATEPLATFORMWINDOWSURFACEPROC>(
+        GetProcAddress("eglCreatePlatformWindowSurface"));
+    DestroyContext =
+        reinterpret_cast<PFNEGLDESTROYCONTEXTPROC>(GetProcAddress("eglDestroyContext"));
+    GetConfigs = reinterpret_cast<PFNEGLGETCONFIGSPROC>(GetProcAddress("eglGetConfigs"));
+    GetCurrentContext =
+        reinterpret_cast<PFNEGLGETCURRENTCONTEXTPROC>(GetProcAddress("eglGetCurrentContext"));
+    GetCurrentDisplay =
+        reinterpret_cast<PFNEGLGETCURRENTDISPLAYPROC>(GetProcAddress("eglGetCurrentDisplay"));
+    GetCurrentSurface =
+        reinterpret_cast<PFNEGLGETCURRENTSURFACEPROC>(GetProcAddress("eglGetCurrentSurface"));
+    GetDisplay = reinterpret_cast<PFNEGLGETDISPLAYPROC>(GetProcAddress("eglGetDisplay"));
+    Initialize = reinterpret_cast<PFNEGLINITIALIZEPROC>(GetProcAddress("eglInitialize"));
+    MakeCurrent = reinterpret_cast<PFNEGLMAKECURRENTPROC>(GetProcAddress("eglMakeCurrent"));
+}
+
+}  // namespace dawn::native::opengl
diff --git a/src/dawn/native/opengl/EGLFunctions.h b/src/dawn/native/opengl/EGLFunctions.h
new file mode 100644
index 0000000..e73e6e9
--- /dev/null
+++ b/src/dawn/native/opengl/EGLFunctions.h
@@ -0,0 +1,42 @@
+// Copyright 2022 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_
+#define SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_
+
+#include <EGL/egl.h>
+
+namespace dawn::native::opengl {
+
+struct EGLFunctions {
+    void Init(void* (*getProc)(const char*));
+    PFNEGLBINDAPIPROC BindAPI;
+    PFNEGLCHOOSECONFIGPROC ChooseConfig;
+    PFNEGLCREATECONTEXTPROC CreateContext;
+    PFNEGLCREATEPLATFORMWINDOWSURFACEPROC CreatePlatformWindowSurface;
+    PFNEGLCREATEPBUFFERSURFACEPROC CreatePbufferSurface;
+    PFNEGLDESTROYCONTEXTPROC DestroyContext;
+    PFNEGLGETCONFIGSPROC GetConfigs;
+    PFNEGLGETCURRENTCONTEXTPROC GetCurrentContext;
+    PFNEGLGETCURRENTDISPLAYPROC GetCurrentDisplay;
+    PFNEGLGETCURRENTSURFACEPROC GetCurrentSurface;
+    PFNEGLGETDISPLAYPROC GetDisplay;
+    PFNEGLGETPROCADDRESSPROC GetProcAddress;
+    PFNEGLINITIALIZEPROC Initialize;
+    PFNEGLMAKECURRENTPROC MakeCurrent;
+};
+
+}  // namespace dawn::native::opengl
+
+#endif  // SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_
diff --git a/src/dawn/native/opengl/OpenGLBackend.cpp b/src/dawn/native/opengl/OpenGLBackend.cpp
index c77c1d0..87cd37f 100644
--- a/src/dawn/native/opengl/OpenGLBackend.cpp
+++ b/src/dawn/native/opengl/OpenGLBackend.cpp
@@ -23,11 +23,11 @@
 
 namespace dawn::native::opengl {
 
-AdapterDiscoveryOptions::AdapterDiscoveryOptions()
-    : AdapterDiscoveryOptionsBase(WGPUBackendType_OpenGL) {}
+AdapterDiscoveryOptions::AdapterDiscoveryOptions(WGPUBackendType type)
+    : AdapterDiscoveryOptionsBase(type) {}
 
 AdapterDiscoveryOptionsES::AdapterDiscoveryOptionsES()
-    : AdapterDiscoveryOptionsBase(WGPUBackendType_OpenGLES) {}
+    : AdapterDiscoveryOptions(WGPUBackendType_OpenGLES) {}
 
 DawnSwapChainImplementation CreateNativeSwapChainImpl(WGPUDevice device,
                                                       PresentCallback present,
diff --git a/src/dawn/native/opengl/OpenGLVersion.cpp b/src/dawn/native/opengl/OpenGLVersion.cpp
index 297b5fb..2c3f0a9 100644
--- a/src/dawn/native/opengl/OpenGLVersion.cpp
+++ b/src/dawn/native/opengl/OpenGLVersion.cpp
@@ -26,9 +26,9 @@
         return DAWN_INTERNAL_ERROR("Couldn't load glGetString");
     }
 
-    std::string version = reinterpret_cast<const char*>(getString(GL_VERSION));
+    const char* version = reinterpret_cast<const char*>(getString(GL_VERSION));
 
-    if (version.find("OpenGL ES") != std::string::npos) {
+    if (strstr(version, "OpenGL ES") != nullptr) {
         // ES spec states that the GL_VERSION string will be in the following format:
         // "OpenGL ES N.M vendor-specific information"
         mStandard = Standard::ES;
@@ -36,7 +36,7 @@
         mMinorVersion = version[12] - '0';
 
         // The minor version shouldn't get to two digits.
-        ASSERT(version.size() <= 13 || !isdigit(version[13]));
+        ASSERT(strlen(version) <= 13 || !isdigit(version[13]));
     } else {
         // OpenGL spec states the GL_VERSION string will be in the following format:
         // <version number><space><vendor-specific information>
@@ -48,7 +48,7 @@
         mMinorVersion = version[2] - '0';
 
         // The minor version shouldn't get to two digits.
-        ASSERT(version.size() <= 3 || !isdigit(version[3]));
+        ASSERT(strlen(version) <= 3 || !isdigit(version[3]));
     }
 
     return {};
diff --git a/src/dawn/samples/SampleUtils.cpp b/src/dawn/samples/SampleUtils.cpp
index ac102a6..c6036c7 100644
--- a/src/dawn/samples/SampleUtils.cpp
+++ b/src/dawn/samples/SampleUtils.cpp
@@ -103,8 +103,8 @@
         return wgpu::Device();
     }
 
-    // Create the test window and discover adapters using it (esp. for OpenGL)
-    utils::SetupGLFWWindowHintsForBackend(backendType);
+    // Create the test window with no client API.
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
     glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE);
     window = glfwCreateWindow(640, 480, "Dawn window", nullptr, nullptr);
     if (!window) {
diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp
index dfd2c54..605ced5 100644
--- a/src/dawn/tests/DawnTest.cpp
+++ b/src/dawn/tests/DawnTest.cpp
@@ -422,31 +422,8 @@
     auto instance = std::make_unique<dawn::native::Instance>();
     instance->EnableBeginCaptureOnStartup(mBeginCaptureOnStartup);
     instance->SetBackendValidationLevel(mBackendValidationLevel);
-    instance->DiscoverDefaultAdapters();
-
-#ifdef DAWN_ENABLE_BACKEND_DESKTOP_GL
-    if (!glfwInit()) {
-        return instance;
-    }
-    glfwDefaultWindowHints();
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-
-    mOpenGLWindow = glfwCreateWindow(400, 400, "Dawn OpenGL test window", nullptr, nullptr);
-    if (mOpenGLWindow != nullptr) {
-        glfwMakeContextCurrent(mOpenGLWindow);
-        dawn::native::opengl::AdapterDiscoveryOptions adapterOptions;
-        adapterOptions.getProc = reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress);
-        instance->DiscoverAdapters(&adapterOptions);
-    }
-#endif  // DAWN_ENABLE_BACKEND_DESKTOP_GL
 
 #ifdef DAWN_ENABLE_BACKEND_OPENGLES
-
-    ScopedEnvironmentVar angleDefaultPlatform;
     if (GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) {
         const char* platform;
         if (!mANGLEBackend.empty()) {
@@ -458,40 +435,15 @@
             platform = "swiftshader";
 #endif
         }
-        angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", platform);
-    }
-
-    if (!glfwInit()) {
-        return instance;
-    }
-    glfwDefaultWindowHints();
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
-    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
-    glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-
-    mOpenGLESWindow = glfwCreateWindow(400, 400, "Dawn OpenGLES test window", nullptr, nullptr);
-    if (mOpenGLESWindow != nullptr) {
-        glfwMakeContextCurrent(mOpenGLESWindow);
-        dawn::native::opengl::AdapterDiscoveryOptionsES adapterOptionsES;
-        adapterOptionsES.getProc = reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress);
-        instance->DiscoverAdapters(&adapterOptionsES);
-        glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
+        SetEnvironmentVar("ANGLE_DEFAULT_PLATFORM", platform);
     }
 #endif  // DAWN_ENABLE_BACKEND_OPENGLES
 
+    instance->DiscoverDefaultAdapters();
+
     return instance;
 }
 
-GLFWwindow* DawnTestEnvironment::GetOpenGLWindow() const {
-    return mOpenGLWindow;
-}
-
-GLFWwindow* DawnTestEnvironment::GetOpenGLESWindow() const {
-    return mOpenGLESWindow;
-}
-
 void DawnTestEnvironment::SelectPreferredAdapterProperties(const dawn::native::Instance* instance) {
     // Get the first available preferred device type.
     wgpu::AdapterType preferredDeviceType = static_cast<wgpu::AdapterType>(-1);
@@ -1129,17 +1081,6 @@
     ASSERT(device);
 
     queue = device.GetQueue();
-
-#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
-    if (IsOpenGL()) {
-        glfwMakeContextCurrent(gTestEnv->GetOpenGLWindow());
-    }
-#endif  // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
-#if defined(DAWN_ENABLE_BACKEND_OPENGLES)
-    if (IsOpenGLES()) {
-        glfwMakeContextCurrent(gTestEnv->GetOpenGLESWindow());
-    }
-#endif  // defined(DAWN_ENABLE_BACKEND_OPENGLES)
 }
 
 void DawnTestBase::TearDown() {
diff --git a/src/dawn/tests/DawnTest.h b/src/dawn/tests/DawnTest.h
index e54ff74..6cbbfe8 100644
--- a/src/dawn/tests/DawnTest.h
+++ b/src/dawn/tests/DawnTest.h
@@ -273,8 +273,6 @@
     std::vector<TestAdapterProperties> mAdapterProperties;
 
     std::unique_ptr<utils::PlatformDebugLogger> mPlatformDebugLogger;
-    GLFWwindow* mOpenGLWindow;
-    GLFWwindow* mOpenGLESWindow;
 };
 
 class DawnTestBase {
diff --git a/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp b/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp
index 7272903..7f3669a 100644
--- a/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp
+++ b/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp
@@ -155,81 +155,6 @@
 }
 #endif  // defined(DAWN_ENABLE_BACKEND_METAL)
 
-#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
-// Test discovering only desktop OpenGL adapters
-TEST(AdapterDiscoveryTests, OnlyDesktopGL) {
-    if (!glfwInit()) {
-        GTEST_SKIP() << "glfwInit() failed";
-    }
-    glfwDefaultWindowHints();
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-
-    GLFWwindow* window = glfwCreateWindow(400, 400, "Dawn OpenGL test window", nullptr, nullptr);
-    glfwMakeContextCurrent(window);
-
-    dawn::native::Instance instance;
-
-    dawn::native::opengl::AdapterDiscoveryOptions options;
-    options.getProc = reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress);
-    instance.DiscoverAdapters(&options);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
-
-    const auto& adapters = instance.GetAdapters();
-    for (const auto& adapter : adapters) {
-        wgpu::AdapterProperties properties;
-        adapter.GetProperties(&properties);
-
-        EXPECT_EQ(properties.backendType, wgpu::BackendType::OpenGL);
-    }
-
-    glfwDestroyWindow(window);
-}
-#endif  // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
-
-#if defined(DAWN_ENABLE_BACKEND_OPENGLES)
-// Test discovering only OpenGLES adapters
-TEST(AdapterDiscoveryTests, OnlyOpenGLES) {
-    ScopedEnvironmentVar angleDefaultPlatform;
-    if (GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) {
-        angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", "swiftshader");
-    }
-
-    if (!glfwInit()) {
-        GTEST_SKIP() << "glfwInit() failed";
-    }
-    glfwDefaultWindowHints();
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
-    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
-    glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-
-    GLFWwindow* window = glfwCreateWindow(400, 400, "Dawn OpenGLES test window", nullptr, nullptr);
-    glfwMakeContextCurrent(window);
-
-    dawn::native::Instance instance;
-
-    dawn::native::opengl::AdapterDiscoveryOptionsES options;
-    options.getProc = reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress);
-    instance.DiscoverAdapters(&options);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
-
-    const auto& adapters = instance.GetAdapters();
-    for (const auto& adapter : adapters) {
-        wgpu::AdapterProperties properties;
-        adapter.GetProperties(&properties);
-
-        EXPECT_EQ(properties.backendType, wgpu::BackendType::OpenGLES);
-    }
-
-    glfwDestroyWindow(window);
-}
-#endif  // defined(DAWN_ENABLE_BACKEND_OPENGLES)
-
 #if defined(DAWN_ENABLE_BACKEND_METAL) && defined(DAWN_ENABLE_BACKEND_VULKAN)
 // Test discovering the Metal backend, then the Vulkan backend
 // does not duplicate adapters.
diff --git a/src/dawn/tests/end2end/SwapChainTests.cpp b/src/dawn/tests/end2end/SwapChainTests.cpp
index c55330d..a7c50e7 100644
--- a/src/dawn/tests/end2end/SwapChainTests.cpp
+++ b/src/dawn/tests/end2end/SwapChainTests.cpp
@@ -37,10 +37,7 @@
             GTEST_SKIP();
         }
 
-        // The SwapChainTests don't create OpenGL contexts so we don't need to call
-        // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL
-        // context that we won't use.
-        ASSERT_TRUE(!IsOpenGL());
+        // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use.
         glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
         window = glfwCreateWindow(400, 400, "SwapChainValidationTests window", nullptr, nullptr);
 
diff --git a/src/dawn/tests/end2end/SwapChainValidationTests.cpp b/src/dawn/tests/end2end/SwapChainValidationTests.cpp
index b351be7..f0a2ff7 100644
--- a/src/dawn/tests/end2end/SwapChainValidationTests.cpp
+++ b/src/dawn/tests/end2end/SwapChainValidationTests.cpp
@@ -34,10 +34,7 @@
         });
         DAWN_TEST_UNSUPPORTED_IF(!glfwInit());
 
-        // The SwapChainValidationTests don't create devices so we don't need to call
-        // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL
-        // context that we won't use.
-        ASSERT_TRUE(!IsOpenGL());
+        // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use.
         glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
         window = glfwCreateWindow(400, 400, "SwapChainValidationTests window", nullptr, nullptr);
 
diff --git a/src/dawn/tests/end2end/WindowSurfaceTests.cpp b/src/dawn/tests/end2end/WindowSurfaceTests.cpp
index b168089..763f19f 100644
--- a/src/dawn/tests/end2end/WindowSurfaceTests.cpp
+++ b/src/dawn/tests/end2end/WindowSurfaceTests.cpp
@@ -68,9 +68,7 @@
     }
 
     GLFWwindow* CreateWindow() {
-        // The WindowSurfaceInstance tests don't create devices so we don't need to call
-        // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL
-        // context that we won't use.
+        // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use.
         glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
         mWindow = glfwCreateWindow(400, 400, "WindowSurfaceInstanceTests window", nullptr, nullptr);
         return mWindow;
diff --git a/src/dawn/utils/BackendBinding.cpp b/src/dawn/utils/BackendBinding.cpp
index 17bea5f..2aaa047 100644
--- a/src/dawn/utils/BackendBinding.cpp
+++ b/src/dawn/utils/BackendBinding.cpp
@@ -16,12 +16,6 @@
 
 #include "dawn/common/Compiler.h"
 
-#include "GLFW/glfw3.h"
-
-#if defined(DAWN_ENABLE_BACKEND_OPENGL)
-#include "dawn/native/OpenGLBackend.h"
-#endif  // defined(DAWN_ENABLE_BACKEND_OPENGL)
-
 namespace utils {
 
 #if defined(DAWN_ENABLE_BACKEND_D3D12)
@@ -43,29 +37,6 @@
 BackendBinding::BackendBinding(GLFWwindow* window, WGPUDevice device)
     : mWindow(window), mDevice(device) {}
 
-void DiscoverAdapter(dawn::native::Instance* instance, GLFWwindow* window, wgpu::BackendType type) {
-    DAWN_UNUSED(type);
-    DAWN_UNUSED(window);
-
-    if (type == wgpu::BackendType::OpenGL || type == wgpu::BackendType::OpenGLES) {
-#if defined(DAWN_ENABLE_BACKEND_OPENGL)
-        glfwMakeContextCurrent(window);
-        auto getProc = reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress);
-        if (type == wgpu::BackendType::OpenGL) {
-            dawn::native::opengl::AdapterDiscoveryOptions adapterOptions;
-            adapterOptions.getProc = getProc;
-            instance->DiscoverAdapters(&adapterOptions);
-        } else {
-            dawn::native::opengl::AdapterDiscoveryOptionsES adapterOptions;
-            adapterOptions.getProc = getProc;
-            instance->DiscoverAdapters(&adapterOptions);
-        }
-#endif  // defined(DAWN_ENABLE_BACKEND_OPENGL)
-    } else {
-        instance->DiscoverDefaultAdapters();
-    }
-}
-
 BackendBinding* CreateBinding(wgpu::BackendType type, GLFWwindow* window, WGPUDevice device) {
     switch (type) {
 #if defined(DAWN_ENABLE_BACKEND_D3D12)
diff --git a/src/dawn/utils/GLFWUtils.cpp b/src/dawn/utils/GLFWUtils.cpp
index 3ba577f..c18ca52 100644
--- a/src/dawn/utils/GLFWUtils.cpp
+++ b/src/dawn/utils/GLFWUtils.cpp
@@ -32,26 +32,6 @@
 
 namespace utils {
 
-void SetupGLFWWindowHintsForBackend(wgpu::BackendType type) {
-    if (type == wgpu::BackendType::OpenGL) {
-        // Ask for OpenGL 4.4 which is what the GL backend requires for compute shaders and
-        // texture views.
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
-        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
-        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    } else if (type == wgpu::BackendType::OpenGLES) {
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
-        glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
-        glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
-    } else {
-        // Without this GLFW will initialize a GL context on the window, which prevents using
-        // the window with other APIs (by crashing in weird ways).
-        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
-    }
-}
-
 wgpu::Surface CreateSurfaceForWindow(const wgpu::Instance& instance, GLFWwindow* window) {
     std::unique_ptr<wgpu::ChainedStruct> chainedDescriptor =
         SetupWindowAndGetSurfaceDescriptor(window);
diff --git a/src/dawn/utils/GLFWUtils.h b/src/dawn/utils/GLFWUtils.h
index 2fe5b10..f42446d 100644
--- a/src/dawn/utils/GLFWUtils.h
+++ b/src/dawn/utils/GLFWUtils.h
@@ -23,10 +23,6 @@
 
 namespace utils {
 
-// Adds all the necessary glfwWindowHint calls for the next GLFWwindow created to be used with
-// the specified backend.
-void SetupGLFWWindowHintsForBackend(wgpu::BackendType type);
-
 // Does the necessary setup on the GLFWwindow to allow creating a wgpu::Surface with it and
 // calls `instance.CreateSurface` with the correct descriptor for this window.
 // Returns a null wgpu::Surface on failure.