Bug 1676925 - Remove code supporting the defunct WebRender experiments. r=jrmuizel,marionette-reviewers
authorAndrew Osmond <aosmond@mozilla.com>
Fri, 13 Nov 2020 05:40:10 +0000
changeset 557102 d9b00e18fe58152b76e79b36d7c5e054dc2f2221
parent 557101 7c39a1568c5e14d3645fdfd52b38e3349880624f
child 557103 7a82edf735870aca22a4cd8e262f8336bf8beee3
push id37947
push userccoroiu@mozilla.com
push dateFri, 13 Nov 2020 16:27:19 +0000
treeherdermozilla-central@7ddb9d55aa38 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjrmuizel, marionette-reviewers
bugs1676925
milestone84.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1676925 - Remove code supporting the defunct WebRender experiments. r=jrmuizel,marionette-reviewers Differential Revision: https://phabricator.services.mozilla.com/D96943
gfx/config/WebRenderRollout.cpp
gfx/config/WebRenderRollout.h
gfx/config/gfxConfigManager.cpp
gfx/config/gfxConfigManager.h
gfx/config/moz.build
gfx/tests/gtest/TestConfigManager.cpp
gfx/tests/marionette/manifest.ini
gfx/tests/marionette/test_pref_rollout_workaround.py
gfx/tests/moz.build
python/mozbuild/mozbuild/action/test_archive.py
python/mozbuild/mozbuild/frontend/context.py
taskcluster/ci/test/marionette.yml
taskcluster/ci/test/test-platforms.yml
taskcluster/ci/test/test-sets.yml
taskcluster/test/data/bugbug-push-schedules.json
testing/marionette/harness/marionette_harness/tests/gpu-unit-tests.ini
deleted file mode 100644
--- a/gfx/config/WebRenderRollout.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "WebRenderRollout.h"
-#include "mozilla/Preferences.h"
-#include "mozilla/ScopeExit.h"
-#include "mozilla/Services.h"
-#include "nsCOMPtr.h"
-#include "nsIObserver.h"
-#include "nsIObserverService.h"
-#include "nsISupportsImpl.h"
-#include "nsXULAppAPI.h"
-
-namespace mozilla {
-namespace gfx {
-
-static const char* const WR_ROLLOUT_PREF = "gfx.webrender.all.qualified";
-static const bool WR_ROLLOUT_PREF_DEFAULTVALUE = true;
-static const char* const WR_ROLLOUT_DEFAULT_PREF =
-    "gfx.webrender.all.qualified.default";
-static const bool WR_ROLLOUT_DEFAULT_PREF_DEFAULTVALUE = false;
-static const char* const WR_ROLLOUT_PREF_OVERRIDE =
-    "gfx.webrender.all.qualified.gfxPref-default-override";
-static const char* const WR_ROLLOUT_HW_QUALIFIED_OVERRIDE =
-    "gfx.webrender.all.qualified.hardware-override";
-static const char* const PROFILE_BEFORE_CHANGE_TOPIC = "profile-before-change";
-
-// If the "gfx.webrender.all.qualified" pref is true we want to enable
-// WebRender for qualified hardware. This pref may be set by the Normandy
-// Preference Rollout feature. The Normandy pref rollout code sets default
-// values on rolled out prefs on every startup. Default pref values are not
-// persisted; they only exist in memory for that session. Gfx starts up
-// before Normandy does. So it's too early to observe the WR qualified pref
-// changed by Normandy rollout on gfx startup. So we add a shutdown observer to
-// save the default value on shutdown, and read the saved value on startup
-// instead.
-class WrRolloutPrefShutdownSaver final : public nsIObserver {
- public:
-  NS_DECL_ISUPPORTS
-
-  NS_IMETHOD Observe(nsISupports*, const char* aTopic,
-                     const char16_t*) override {
-    if (strcmp(PROFILE_BEFORE_CHANGE_TOPIC, aTopic) != 0) {
-      // Not the observer we're looking for, move along.
-      return NS_OK;
-    }
-
-    SaveRolloutPref();
-
-    // Shouldn't receive another notification, remove the observer.
-    RefPtr<WrRolloutPrefShutdownSaver> kungFuDeathGrip(this);
-    nsCOMPtr<nsIObserverService> observerService =
-        mozilla::services::GetObserverService();
-    if (NS_WARN_IF(!observerService)) {
-      return NS_ERROR_FAILURE;
-    }
-    observerService->RemoveObserver(this, PROFILE_BEFORE_CHANGE_TOPIC);
-    return NS_OK;
-  }
-
-  static void AddShutdownObserver() {
-    MOZ_ASSERT(XRE_IsParentProcess());
-    nsCOMPtr<nsIObserverService> observerService =
-        mozilla::services::GetObserverService();
-    if (NS_WARN_IF(!observerService)) {
-      return;
-    }
-    RefPtr<WrRolloutPrefShutdownSaver> wrRolloutSaver =
-        new WrRolloutPrefShutdownSaver();
-    observerService->AddObserver(wrRolloutSaver, PROFILE_BEFORE_CHANGE_TOPIC,
-                                 false);
-  }
-
- private:
-  virtual ~WrRolloutPrefShutdownSaver() = default;
-
-  void SaveRolloutPref() {
-    if (Preferences::HasUserValue(WR_ROLLOUT_PREF) ||
-        Preferences::GetType(WR_ROLLOUT_PREF) == nsIPrefBranch::PREF_INVALID) {
-      // Don't need to create a backup of default value, because either:
-      // 1. the user or the WR SHIELD study has set a user pref value, or
-      // 2. we've not had a default pref set by Normandy that needs to be saved
-      //    for reading before Normandy has started up.
-      return;
-    }
-
-    bool defaultValue =
-        Preferences::GetBool(WR_ROLLOUT_PREF, false, PrefValueKind::Default);
-    Preferences::SetBool(WR_ROLLOUT_DEFAULT_PREF, defaultValue);
-  }
-};
-
-NS_IMPL_ISUPPORTS(WrRolloutPrefShutdownSaver, nsIObserver)
-
-/* static */ void WebRenderRollout::Init() {
-  WrRolloutPrefShutdownSaver::AddShutdownObserver();
-}
-
-/* static */ Maybe<bool> WebRenderRollout::CalculateQualifiedOverride() {
-  // This pref only ever gets set in test_pref_rollout_workaround, and in
-  // that case we want to ignore the MOZ_WEBRENDER=0 that will be set by
-  // the test harness so as to actually make the test work.
-  if (!Preferences::HasUserValue(WR_ROLLOUT_HW_QUALIFIED_OVERRIDE)) {
-    return Nothing();
-  }
-  return Some(Preferences::GetBool(WR_ROLLOUT_HW_QUALIFIED_OVERRIDE, false));
-}
-
-// If the "gfx.webrender.all.qualified" pref is true we want to enable
-// WebRender for qualifying hardware. The Normandy pref rollout code sets
-// default values on rolled out prefs on every startup, but Gfx starts up
-// before Normandy does. So it's too early to observe the WR qualified pref
-// default value changed by Normandy rollout here yet. So we have a shutdown
-// observer to save the default value on shutdown, and read the saved default
-// value here instead, and emulate the behavior of the pref system, with
-// respect to default/user values of the rollout pref.
-/* static */ bool WebRenderRollout::CalculateQualified() {
-  auto clearPrefOnExit = MakeScopeExit([]() {
-    // Clear the mirror of the default value of the rollout pref on scope exit,
-    // if we have one. This ensures the user doesn't mess with the pref.
-    // If we need it again, we'll re-create it on shutdown.
-    Preferences::ClearUser(WR_ROLLOUT_DEFAULT_PREF);
-  });
-
-  if (!Preferences::HasUserValue(WR_ROLLOUT_PREF) &&
-      Preferences::HasUserValue(WR_ROLLOUT_DEFAULT_PREF)) {
-    // The user has not set a user pref, and we have a default value set by the
-    // shutdown observer. Let's use this as it should be the value Normandy set
-    // before startup. WR_ROLLOUT_DEFAULT_PREF should only be set on shutdown by
-    // the shutdown observer.
-    // Normandy runs *during* startup, but *after* this code here runs (hence
-    // the need for the workaround).
-    // To have a value stored in the WR_ROLLOUT_DEFAULT_PREF pref here, during
-    // the previous run Normandy must have set a default value on the in-memory
-    // pref, and on shutdown we stored the default value in this
-    // WR_ROLLOUT_DEFAULT_PREF user pref. Then once the user restarts, we
-    // observe this pref. Normandy is the only way a default (not user) value
-    // can be set for this pref.
-    return Preferences::GetBool(WR_ROLLOUT_DEFAULT_PREF,
-                                WR_ROLLOUT_DEFAULT_PREF_DEFAULTVALUE);
-  }
-
-  // We don't have a user value for the rollout pref, and we don't have the
-  // value of the rollout pref at last shutdown stored. So we should fallback
-  // to using the default. *But* if we're running
-  // under the Marionette pref rollout work-around test, we may want to override
-  // the default value expressed here, so we can test the "default disabled;
-  // rollout pref enabled" case.
-  // Note that those preferences can't be defined in all.js nor
-  // StaticPrefsList.h as they would create the pref, leading SaveRolloutPref()
-  // above to abort early as the pref would have a valid type.
-  //  We also don't want those prefs to appear in about:config.
-  if (Preferences::HasUserValue(WR_ROLLOUT_PREF_OVERRIDE)) {
-    return Preferences::GetBool(WR_ROLLOUT_PREF_OVERRIDE);
-  }
-  return Preferences::GetBool(WR_ROLLOUT_PREF, WR_ROLLOUT_PREF_DEFAULTVALUE);
-}
-
-}  // namespace gfx
-}  // namespace mozilla
deleted file mode 100644
--- a/gfx/config/WebRenderRollout.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-#ifndef mozilla_gfx_config_WebRenderRollout_h
-#define mozilla_gfx_config_WebRenderRollout_h
-
-#include "mozilla/Maybe.h"
-
-namespace mozilla {
-namespace gfx {
-
-class WebRenderRollout final {
- public:
-  static void Init();
-  static Maybe<bool> CalculateQualifiedOverride();
-  static bool CalculateQualified();
-
-  WebRenderRollout() = delete;
-  ~WebRenderRollout() = delete;
-};
-
-}  // namespace gfx
-}  // namespace mozilla
-
-#endif  // mozilla_gfx_config_WebRenderRollout_h
--- a/gfx/config/gfxConfigManager.cpp
+++ b/gfx/config/gfxConfigManager.cpp
@@ -2,40 +2,36 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/gfx/gfxConfigManager.h"
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
 #include "mozilla/StaticPrefs_gfx.h"
 #include "mozilla/StaticPrefs_layers.h"
 #include "gfxConfig.h"
 #include "gfxPlatform.h"
 #include "nsIGfxInfo.h"
 #include "nsXULAppAPI.h"
-#include "WebRenderRollout.h"
 
 #ifdef XP_WIN
 #  include "mozilla/WindowsVersion.h"
 #  include "mozilla/gfx/DeviceManagerDx.h"
 #  include "mozilla/gfx/DisplayConfigWindows.h"
 #endif
 
 namespace mozilla {
 namespace gfx {
 
 void gfxConfigManager::Init() {
   MOZ_ASSERT(XRE_IsParentProcess());
 
-  WebRenderRollout::Init();
-  mWrQualifiedOverride = WebRenderRollout::CalculateQualifiedOverride();
-  mWrQualified = WebRenderRollout::CalculateQualified();
-
   EmplaceUserPref("gfx.webrender.compositor", mWrCompositorEnabled);
   mWrForceEnabled = gfxPlatform::WebRenderPrefEnabled();
   mWrForceDisabled = StaticPrefs::gfx_webrender_force_disabled_AtStartup();
   mWrCompositorForceEnabled =
       StaticPrefs::gfx_webrender_compositor_force_enabled_AtStartup();
   mGPUProcessAllowSoftware =
       StaticPrefs::layers_gpu_process_allow_software_AtStartup();
   mWrPartialPresent =
@@ -146,49 +142,34 @@ void gfxConfigManager::ConfigureWebRende
     case nsIGfxInfo::FEATURE_STATUS_OK:
       MOZ_ASSERT_UNREACHABLE("We should still be rolling out WebRender!");
       mFeatureWrSoftware->Disable(FeatureStatus::Blocked,
                                   "Not controlled by rollout", failureId);
       break;
   }
 }
 
-bool gfxConfigManager::ConfigureWebRenderQualified() {
+void gfxConfigManager::ConfigureWebRenderQualified() {
   MOZ_ASSERT(mFeatureWrQualified);
   MOZ_ASSERT(mFeatureWrCompositor);
 
-  bool guarded = true;
   mFeatureWrQualified->EnableByDefault();
 
-  if (mWrQualifiedOverride) {
-    if (!*mWrQualifiedOverride) {
-      mFeatureWrQualified->Disable(
-          FeatureStatus::BlockedOverride, "HW qualification pref override",
-          "FEATURE_FAILURE_WR_QUALIFICATION_OVERRIDE"_ns);
-    }
-    return guarded;
-  }
-
   nsCString failureId;
   int32_t status;
   if (NS_FAILED(mGfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRENDER,
                                            failureId, &status))) {
     mFeatureWrQualified->Disable(FeatureStatus::BlockedNoGfxInfo,
                                  "gfxInfo is broken",
                                  "FEATURE_FAILURE_WR_NO_GFX_INFO"_ns);
-    return guarded;
+    return;
   }
 
   switch (status) {
     case nsIGfxInfo::FEATURE_ALLOW_ALWAYS:
-      // We want to honour ALLOW_ALWAYS on beta and release, but on nightly,
-      // we still want to perform experiments. A larger population is the most
-      // useful, demote nightly to merely qualified.
-      guarded = mIsNightly;
-      break;
     case nsIGfxInfo::FEATURE_ALLOW_QUALIFIED:
       break;
     case nsIGfxInfo::FEATURE_DENIED:
       mFeatureWrQualified->Disable(FeatureStatus::Denied, "Not on allowlist",
                                    failureId);
       break;
     default:
       mFeatureWrQualified->Disable(FeatureStatus::Blocklisted,
@@ -218,18 +199,16 @@ bool gfxConfigManager::ConfigureWebRende
       int32_t maxRefreshRate = mGfxInfo->GetMaxRefreshRate(&mixed);
       if (maxRefreshRate > 60 && mixed) {
         mFeatureWrQualified->Disable(FeatureStatus::Blocked,
                                      "Monitor refresh rate too high/mixed",
                                      "NVIDIA_REFRESH_RATE_MIXED"_ns);
       }
     }
   }
-
-  return guarded;
 }
 
 void gfxConfigManager::ConfigureWebRender() {
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(mFeatureWr);
   MOZ_ASSERT(mFeatureWrQualified);
   MOZ_ASSERT(mFeatureWrCompositor);
   MOZ_ASSERT(mFeatureWrAngle);
@@ -259,52 +238,44 @@ void gfxConfigManager::ConfigureWebRende
         mHwStretchingSupport.mBoth, mHwStretchingSupport.mWindowOnly,
         mHwStretchingSupport.mFullScreenOnly, mHwStretchingSupport.mNone,
         mHwStretchingSupport.mError);
     mFeatureWrCompositor->Disable(FeatureStatus::Unavailable,
                                   "No hardware stretching support", failureId);
   }
 
   ConfigureWebRenderSoftware();
-
-  bool guardedByQualifiedPref = ConfigureWebRenderQualified();
+  ConfigureWebRenderQualified();
 
   mFeatureWr->EnableByDefault();
 
   // envvar works everywhere; note that we need this for testing in CI.
   // Prior to bug 1523788, the `prefEnabled` check was only done on Nightly,
   // so as to prevent random users from easily enabling WebRender on
   // unqualified hardware in beta/release.
   if (mWrEnvForceEnabled) {
     mFeatureWr->UserForceEnable("Force enabled by envvar");
   } else if (mWrForceEnabled) {
     mFeatureWr->UserForceEnable("Force enabled by pref");
-  } else if (mWrForceDisabled ||
-             (mWrEnvForceDisabled && mWrQualifiedOverride.isNothing())) {
+  } else if (mWrForceDisabled || mWrEnvForceDisabled) {
     // If the user set the pref to force-disable, let's do that. This
     // will override all the other enabling prefs
     // (gfx.webrender.enabled, gfx.webrender.all, and
     // gfx.webrender.all.qualified).
     mFeatureWr->UserDisable("User force-disabled WR",
                             "FEATURE_FAILURE_USER_FORCE_DISABLED"_ns);
   }
 
   if (!mFeatureWrQualified->IsEnabled()) {
     // No qualified hardware. If we haven't allowed software fallback,
     // then we need to disable WR.
     if (!mFeatureWrSoftware->IsEnabled()) {
       mFeatureWr->Disable(FeatureStatus::Disabled, "Not qualified",
                           "FEATURE_FAILURE_NOT_QUALIFIED"_ns);
     }
-  } else if (guardedByQualifiedPref && !mWrQualified) {
-    // If the HW is qualified, we enable if either the HW has been qualified
-    // on the release channel (i.e. it's no longer guarded by the qualified
-    // pref), or if the qualified pref is enabled.
-    mFeatureWr->Disable(FeatureStatus::Disabled, "Control group for experiment",
-                        "FEATURE_FAILURE_IN_EXPERIMENT"_ns);
   } else {
     // Otherwise we have qualified hardware, so we can disable the software
     // feature. Note that this doesn't override the force-enabled state set by
     // the pref, so the pref will still enable software.
     mFeatureWrSoftware->Disable(FeatureStatus::Disabled,
                                 "Overriden by qualified hardware",
                                 "FEATURE_FAILURE_OVERRIDEN"_ns);
   }
--- a/gfx/config/gfxConfigManager.h
+++ b/gfx/config/gfxConfigManager.h
@@ -4,16 +4,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef mozilla_gfx_config_gfxConfigManager_h
 #define mozilla_gfx_config_gfxConfigManager_h
 
 #include "gfxFeature.h"
 #include "gfxTypes.h"
 
+class nsIGfxInfo;
+
 namespace mozilla {
 namespace gfx {
 
 class gfxConfigManager {
  public:
   gfxConfigManager()
       : mFeatureWr(nullptr),
         mFeatureWrQualified(nullptr),
@@ -23,17 +25,16 @@ class gfxConfigManager {
         mFeatureWrPartial(nullptr),
         mFeatureWrSoftware(nullptr),
         mFeatureHwCompositing(nullptr),
         mFeatureD3D11HwAngle(nullptr),
         mFeatureGPUProcess(nullptr),
         mWrForceEnabled(false),
         mWrForceDisabled(false),
         mWrCompositorForceEnabled(false),
-        mWrQualified(false),
         mWrForceAngle(false),
         mWrForceAngleNoGPUProcess(false),
         mWrDCompWinEnabled(false),
         mWrCompositorDCompRequired(false),
         mWrPartialPresent(false),
         mGPUProcessAllowSoftware(false),
         mXRenderEnabled(false),
         mWrEnvForceEnabled(false),
@@ -46,17 +47,17 @@ class gfxConfigManager {
 
   void Init();
 
   void ConfigureWebRender();
   void ConfigureFromBlocklist(long aFeature, FeatureState* aFeatureState);
 
  protected:
   void EmplaceUserPref(const char* aPrefName, Maybe<bool>& aValue);
-  bool ConfigureWebRenderQualified();
+  void ConfigureWebRenderQualified();
   void ConfigureWebRenderSoftware();
 
   nsCOMPtr<nsIGfxInfo> mGfxInfo;
 
   FeatureState* mFeatureWr;
   FeatureState* mFeatureWrQualified;
   FeatureState* mFeatureWrCompositor;
   FeatureState* mFeatureWrAngle;
@@ -70,18 +71,16 @@ class gfxConfigManager {
 
   /**
    * Prefs
    */
   Maybe<bool> mWrCompositorEnabled;
   bool mWrForceEnabled;
   bool mWrForceDisabled;
   bool mWrCompositorForceEnabled;
-  bool mWrQualified;
-  Maybe<bool> mWrQualifiedOverride;
   bool mWrForceAngle;
   bool mWrForceAngleNoGPUProcess;
   bool mWrDCompWinEnabled;
   bool mWrCompositorDCompRequired;
   bool mWrPartialPresent;
   bool mGPUProcessAllowSoftware;
   bool mXRenderEnabled;
 
--- a/gfx/config/moz.build
+++ b/gfx/config/moz.build
@@ -16,14 +16,13 @@ EXPORTS.mozilla.gfx += [
     "gfxVars.h",
 ]
 
 UNIFIED_SOURCES += [
     "gfxConfig.cpp",
     "gfxConfigManager.cpp",
     "gfxFeature.cpp",
     "gfxVars.cpp",
-    "WebRenderRollout.cpp",
 ]
 
 include("/ipc/chromium/chromium-config.mozbuild")
 
 FINAL_LIBRARY = "xul"
--- a/gfx/tests/gtest/TestConfigManager.cpp
+++ b/gfx/tests/gtest/TestConfigManager.cpp
@@ -256,17 +256,16 @@ class GfxConfigManager : public ::testin
 
     // By default, turn everything on. This effectively assumes we are on
     // qualified nightly Windows 10 with DirectComposition support.
     mFeatureHwCompositing->EnableByDefault();
     mFeatureD3D11HwAngle->EnableByDefault();
     mFeatureGPUProcess->EnableByDefault();
 
     mWrCompositorEnabled.emplace(true);
-    mWrQualified = true;
     mWrPartialPresent = true;
     mWrForceAngle = true;
     mWrDCompWinEnabled = true;
     mWrCompositorDCompRequired = true;
     ++mHwStretchingSupport.mBoth;
     mIsWin10OrLater = true;
     mIsNightly = true;
   }
@@ -380,60 +379,44 @@ TEST_F(GfxConfigManager, WebRenderEnable
   EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
   EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
   EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
 }
 
 TEST_F(GfxConfigManager, WebRenderDisabledWithDisableHwCompositingNoWr) {
   mDisableHwCompositingNoWr = true;
-  mWrQualified = false;
+  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_DENIED;
   ConfigureWebRender();
 
-  EXPECT_TRUE(mFeatures.mWrQualified.IsEnabled());
+  EXPECT_FALSE(mFeatures.mWrQualified.IsEnabled());
   EXPECT_FALSE(mFeatures.mWr.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
   EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled());
   EXPECT_FALSE(mFeatures.mGPUProcess.IsEnabled());
   EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
 }
 
 TEST_F(GfxConfigManager, WebRenderDisabledWithAllowSoftwareGPUProcess) {
   mDisableHwCompositingNoWr = true;
-  mWrQualified = false;
+  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_DENIED;
   mGPUProcessAllowSoftware = true;
   ConfigureWebRender();
 
-  EXPECT_TRUE(mFeatures.mWrQualified.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
-  EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled());
-  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
-  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
-}
-
-TEST_F(GfxConfigManager, WebRenderQualifiedOverrideDisabled) {
-  mWrQualifiedOverride.emplace(false);
-  ConfigureWebRender();
-
   EXPECT_FALSE(mFeatures.mWrQualified.IsEnabled());
   EXPECT_FALSE(mFeatures.mWr.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
-  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
+  EXPECT_FALSE(mFeatures.mHwCompositing.IsEnabled());
   EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
   EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
 }
 
 TEST_F(GfxConfigManager, WebRenderSafeMode) {
   mSafeMode = true;
   ConfigureWebRender();
@@ -592,51 +575,16 @@ TEST_F(GfxConfigManager, WebRenderQualif
   EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
   EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
   EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
   EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
   EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
 }
 
-TEST_F(GfxConfigManager, WebRenderNotQualifiedAndBlocklistAllowQualified) {
-  mWrQualified = false;
-  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_ALLOW_QUALIFIED;
-  ConfigureWebRender();
-
-  EXPECT_TRUE(mFeatures.mWrQualified.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWr.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrCompositor.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrAngle.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrDComp.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrPartial.IsEnabled());
-  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
-  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
-  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
-}
-
-TEST_F(GfxConfigManager, WebRenderNotQualifiedAndBlocklistAllowAlways) {
-  mWrQualified = false;
-  mIsNightly = false;
-  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_ALLOW_ALWAYS;
-  ConfigureWebRender();
-
-  EXPECT_TRUE(mFeatures.mWrQualified.IsEnabled());
-  EXPECT_TRUE(mFeatures.mWr.IsEnabled());
-  EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
-  EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
-  EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
-  EXPECT_TRUE(mFeatures.mWrPartial.IsEnabled());
-  EXPECT_TRUE(mFeatures.mHwCompositing.IsEnabled());
-  EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
-  EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
-  EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
-}
-
 TEST_F(GfxConfigManager, WebRenderIntelBatteryNoHwStretchingNotNightly) {
   mIsNightly = false;
   ++mHwStretchingSupport.mNone;
   mScaledResolution = true;
   mMockGfxInfo->mHasBattery.ref() = true;
   mMockGfxInfo->mVendorId = "0x8086";
   ConfigureWebRender();
 
@@ -809,17 +757,17 @@ TEST_F(GfxConfigManager, WebRenderSofwar
   EXPECT_TRUE(mFeatures.mGPUProcess.IsEnabled());
   EXPECT_TRUE(mFeatures.mD3D11HwAngle.IsEnabled());
   EXPECT_FALSE(mFeatures.mWrSoftware.IsEnabled());
 }
 
 TEST_F(GfxConfigManager, WebRenderSofwareAndNotQualified) {
   // Enabling software in gfxInfo when we're not qualified
   // results in WR software being enabled instead.
-  mWrQualifiedOverride.emplace(false);
+  mMockGfxInfo->mStatusWr = nsIGfxInfo::FEATURE_DENIED;
   mMockGfxInfo->mStatusWrSoftware = nsIGfxInfo::FEATURE_ALLOW_ALWAYS;
   ConfigureWebRender();
 
   EXPECT_FALSE(mFeatures.mWrQualified.IsEnabled());
   EXPECT_TRUE(mFeatures.mWr.IsEnabled());
   EXPECT_TRUE(mFeatures.mWrCompositor.IsEnabled());
   EXPECT_TRUE(mFeatures.mWrAngle.IsEnabled());
   EXPECT_TRUE(mFeatures.mWrDComp.IsEnabled());
deleted file mode 100644
--- a/gfx/tests/marionette/manifest.ini
+++ /dev/null
@@ -1,5 +0,0 @@
-[DEFAULT]
-run-if = buildapp == 'browser'
-
-[test_pref_rollout_workaround.py]
-skip-if = os != "win" # Bug 1503776, WebRender is only available on Windows at this stage.
deleted file mode 100644
--- a/gfx/tests/marionette/test_pref_rollout_workaround.py
+++ /dev/null
@@ -1,167 +0,0 @@
-# -*- coding: utf-8 -*-
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-from __future__ import absolute_import, print_function
-import platform
-from unittest import skipIf
-
-from marionette_driver.by import By
-from marionette_harness.marionette_test import MarionetteTestCase
-
-
-gfx_rollout_override = "gfx.webrender.all.qualified.gfxPref-default-override"
-hw_qualified_override = "gfx.webrender.all.qualified.hardware-override"
-rollout_pref = "gfx.webrender.all.qualified"
-
-
-class WrPrefRolloutWorkAroundTestCase(MarionetteTestCase):
-    """Test cases for WebRender gradual pref rollout work around.
-    Normandy sets default prefs when rolling out a pref change, but
-    gfx starts up before Normandy can set the pref's default value
-    so we save the default value on shutdown, and check it on startup.
-    This test verifies that we save and load the default value,
-    and that the right compositor is enabled due to the rollout.
-    """
-
-    def test_wr_rollout_workaround_on_non_qualifying_hw(self):
-        # Override the StaticPrefs so that WR is not enabled, as it would be before a rollout.
-        self.marionette.set_pref(pref=gfx_rollout_override, value=False)
-        # Set HW override so we behave as if we on non-qualifying hardware.
-        self.marionette.set_pref(pref=hw_qualified_override, value=False)
-        # Ensure we don't fallback to the basic compositor for some spurious reason.
-        self.marionette.set_pref(pref="layers.acceleration.force-enabled", value=True)
-
-        # Restart browser. Gfx will observe hardware qualification override, and
-        # gfx rollout override prefs. We should then be running in a browser which
-        # behaves as if it's running on hardware that does not qualify for WR,
-        # with WR not rolled out yet.
-        self.marionette.restart(clean=False, in_app=True)
-
-        # Ensure we're not yet using WR; we're not rolled out yet!
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "disabled:FEATURE_FAILURE_NOT_QUALIFIED",
-            "Should start out as WR disabled, not qualified",
-        )
-        self.assertTrue(
-            compositor != "webrender",
-            "Before WR rollout on non-qualifying HW, should not be using WR.",
-        )
-
-        # Set the rollout pref's default value, as Normandy would do, and restart.
-        # Gfx's shutdown observer should save the default value of the pref. Upon
-        # restart, because we're pretending to be on *non-qualifying* hardware, WR
-        # should be reported as blocked.
-        self.marionette.set_pref(pref=rollout_pref, value=True, default_branch=True)
-        self.marionette.restart(clean=False, in_app=True)
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "disabled:FEATURE_FAILURE_NOT_QUALIFIED",
-            "WR rolled out on non-qualifying hardware should not use WR.",
-        )
-        self.assertTrue(
-            compositor != "webrender",
-            "WR rolled out on non-qualifying HW should not be used.",
-        )
-
-        # Simulate a rollback of the rollout; set the pref to false at runtime.
-        self.marionette.set_pref(pref=rollout_pref, value=False, default_branch=True)
-        self.marionette.restart(clean=False, in_app=True)
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "disabled:FEATURE_FAILURE_NOT_QUALIFIED",
-            "WR rollback of rollout should revert to disabled on non-qualifying hardware.",
-        )
-        self.assertTrue(
-            compositor != "webrender",
-            "After roll back on non-qualifying HW, WR should not be used.",
-        )
-
-    @skipIf(
-        platform.machine() == "ARM64" and platform.system() == "Windows",
-        "Bug 1536369 - Crashes on Windows 10 aarch64",
-    )
-    def test_wr_rollout_workaround_on_qualifying_hw(self):
-        # Override the gfxPref so that WR is not enabled, as it would be before a rollout.
-        self.marionette.set_pref(pref=gfx_rollout_override, value=False)
-        # Set HW override so we behave as if we on qualifying hardware.
-        self.marionette.set_pref(pref=hw_qualified_override, value=True)
-        self.marionette.set_pref(pref="layers.acceleration.force-enabled", value=True)
-
-        # Restart browser. Gfx will observe hardware qualification override, and
-        # gfx rollout override prefs. We should then be running in a browser which
-        # behaves as if it's running on *qualifying* hardware, with WR not rolled
-        # out yet.
-        self.marionette.restart(clean=False, in_app=True)
-
-        # Ensure we're not yet using WR; we're not rolled out yet!
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "disabled:FEATURE_FAILURE_IN_EXPERIMENT",
-            "Should start out as WR disabled, in experiment",
-        )
-        self.assertTrue(
-            compositor != "webrender",
-            "Before WR rollout on qualifying HW, should not be using WR.",
-        )
-
-        # Set the rollout pref's default value, as Normandy would do, and restart.
-        # Gfx's shutdown observer should save the default value of the pref. Upon
-        # restart, because we're pretending to be on *qualifying* hardware, WR
-        # should be reported as available.
-        self.marionette.set_pref(pref=rollout_pref, value=True, default_branch=True)
-        self.marionette.restart(clean=False, in_app=True)
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "available",
-            "WR rolled out on qualifying hardware should report be available #1.",
-        )
-        self.assertEqual(
-            compositor,
-            "webrender",
-            "After rollout on qualifying HW, WR should be used.",
-        )
-
-        # Simulate a rollback of the rollout; set the pref to false at runtime.
-        self.marionette.set_pref(pref=rollout_pref, value=False, default_branch=True)
-        self.marionette.restart(clean=False, in_app=True)
-        status, compositor = self.wr_status()
-        print("self.wr_status()={},{}".format(status, compositor))
-        self.assertEqual(
-            status,
-            "disabled:FEATURE_FAILURE_IN_EXPERIMENT",
-            "WR rollback of rollout should revert to disabled on qualifying hardware.",
-        )
-        self.assertTrue(
-            compositor != "webrender",
-            "After roll back on qualifying HW, WR should not be used.",
-        )
-
-    def wr_status(self):
-        self.marionette.set_context(self.marionette.CONTEXT_CHROME)
-        result = self.marionette.execute_script(
-            """
-            try {
-                const gfxInfo = Components.classes['@mozilla.org/gfx/info;1'].getService(Ci.nsIGfxInfo);
-                return {features: gfxInfo.getFeatures(), log: gfxInfo.getFeatureLog()};
-            } catch (e) {
-                return {}
-            }
-        """
-        )
-        return (
-            result["features"]["webrender"]["status"],
-            result["features"]["compositor"],
-        )
--- a/gfx/tests/moz.build
+++ b/gfx/tests/moz.build
@@ -2,9 +2,8 @@
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 MOCHITEST_MANIFESTS += ["mochitest/mochitest.ini"]
 BROWSER_CHROME_MANIFESTS += ["browser/browser.ini"]
 MOCHITEST_CHROME_MANIFESTS += ["chrome/chrome.ini"]
-MARIONETTE_GPU_MANIFESTS += ["marionette/manifest.ini"]
--- a/python/mozbuild/mozbuild/action/test_archive.py
+++ b/python/mozbuild/mozbuild/action/test_archive.py
@@ -134,17 +134,16 @@ ARCHIVE_FILES = {
                 "harness/marionette_harness/tests",
             ],
         },
         {
             "source": buildconfig.topsrcdir,
             "base": "",
             "manifests": [
                 "testing/marionette/harness/marionette_harness/tests/unit-tests.ini",
-                "gfx/tests/marionette/manifest.ini",
             ],
             # We also need the manifests and harness_unit tests
             "pattern": "testing/marionette/harness/marionette_harness/tests/**",
             "dest": "marionette/tests",
         },
         {
             "source": buildconfig.topobjdir,
             "base": "_tests",
--- a/python/mozbuild/mozbuild/frontend/context.py
+++ b/python/mozbuild/mozbuild/frontend/context.py
@@ -2234,22 +2234,16 @@ VARIABLES = {
         """,
     ),
     "MARIONETTE_LAYOUT_MANIFESTS": (
         ManifestparserManifestList,
         list,
         """List of manifest files defining marionette-layout tests.
         """,
     ),
-    "MARIONETTE_GPU_MANIFESTS": (
-        ManifestparserManifestList,
-        list,
-        """List of manifest files defining marionette-gpu tests.
-        """,
-    ),
     "MARIONETTE_UNIT_MANIFESTS": (
         ManifestparserManifestList,
         list,
         """List of manifest files defining marionette-unit tests.
         """,
     ),
     "METRO_CHROME_MANIFESTS": (
         ManifestparserManifestList,
--- a/taskcluster/ci/test/marionette.yml
+++ b/taskcluster/ci/test/marionette.yml
@@ -62,17 +62,8 @@ marionette-headless:
     description: "Marionette headless unittest run"
     treeherder-symbol: MnH
     max-run-time: 5400
     instance-size: default
     tier: 2
     mozharness:
         extra-options:
             - --headless
-
-marionette-gpu:
-    description: "Marionette with GPU unittest run"
-    treeherder-symbol: MnG
-    max-run-time: 1800
-    instance-size: default
-    mozharness:
-        extra-options:
-            - --test-manifest gpu-unit-tests.ini
--- a/taskcluster/ci/test/test-platforms.yml
+++ b/taskcluster/ci/test/test-platforms.yml
@@ -222,21 +222,16 @@ windows7-32-qr/opt:
     build-platform: win64/opt
     test-sets:
         - awsy
         - windows-qr-tests
         - windows-talos
         - web-platform-tests
 
 # win64
-windows10-64-ccov/opt:
-    build-platform: win64-ccov/opt
-    test-sets:
-        - marionette-gpu-tests  # fails on -qr because one test requires WR disabled
-
 windows10-64-ccov-qr/opt:
     build-platform: win64-ccov/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - windows-reftest-gpu
         - windows-talos
         - windows-tests
@@ -244,30 +239,28 @@ windows10-64-ccov-qr/opt:
         - windows10-tests
         - web-platform-tests
         - ccov-code-coverage-tests
         - mochitest-webgpu
 
 windows10-64/debug:
     build-platform: win64/debug
     test-sets:
-        - marionette-gpu-tests
         - mochitest-webgpu
         - windows-tests
         - windows10-tests
         - web-platform-tests
 
 windows10-64/opt:
     build-platform: win64/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - windows-talos
         - marionette-framescript
-        - marionette-gpu-tests
         - windows-tests
         - windows10-tests
         - web-platform-tests
         - web-platform-tests-backlog
         - raptor-firefox
         - browsertime
         - mochitest-webgpu
         - web-platform-tests-wdspec-headless
@@ -286,17 +279,16 @@ windows10-64-ref-hw-2017/opt:
 
 windows10-64-shippable/opt:
     build-platform: win64-shippable/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - windows-talos
         - marionette-framescript
-        - marionette-gpu-tests
         - windows-tests
         - windows10-tests
         - web-platform-tests
         - web-platform-tests-backlog
         - web-platform-tests-wdspec-headless
         - raptor-chrome
         - raptor-chromium
         - raptor-firefox
@@ -304,17 +296,16 @@ windows10-64-shippable/opt:
         - raptor-profiling
         - talos-profiling
         - mochitest-webgpu
 
 windows10-64-devedition/opt:
     build-platform: win64-devedition/opt
     test-sets:
         - desktop-screenshot-capture
-        - marionette-gpu-tests
         - windows-tests
         - windows10-tests
         - web-platform-tests
         - mochitest-webgpu
 
 windows10-64-asan/opt:
     build-platform: win64-asan/opt
     test-sets:
--- a/taskcluster/ci/test/test-sets.yml
+++ b/taskcluster/ci/test/test-sets.yml
@@ -182,19 +182,16 @@ awsy:
     - awsy-dmd
     - awsy-base-dmd
     - awsy-tp6
 
 ccov-code-coverage-tests:
     - test-coverage
     - test-coverage-wpt
 
-marionette-gpu-tests:
-    - marionette-gpu
-
 mochitest-headless:
     - mochitest-plain-headless
 
 mochitest-valgrind:
     - mochitest-valgrind
 
 marionette-framescript:
     - marionette-framescript
--- a/taskcluster/test/data/bugbug-push-schedules.json
+++ b/taskcluster/test/data/bugbug-push-schedules.json
@@ -2803,17 +2803,16 @@
     "test-macosx1014-64/opt-web-platform-tests-reftest-e10s-3",
     "test-linux1804-64-qr/opt-xpcshell-e10s-2",
     "test-linux1804-64-qr/debug-xpcshell-e10s-2",
     "test-linux1804-64/debug-reftest-e10s-6",
     "test-windows10-64-qr/debug-web-platform-tests-reftest-e10s-4",
     "test-windows10-64-shippable-qr/opt-raptor-tp6-firefox-cold-docs-e10s",
     "test-linux1804-64-qr/debug-web-platform-tests-wdspec-fis-e10s-2",
     "test-linux1804-64-asan/opt-mochitest-devtools-chrome-e10s-5",
-    "test-windows10-64/debug-marionette-gpu-fis-e10s",
     "test-windows10-64/opt-mochitest-a11y-1proc",
     "test-macosx1014-64-shippable/opt-raptor-tp6-firefox-cold-reddit-e10s",
     "test-macosx1014-64/debug-mochitest-media-e10s-1",
     "test-windows7-32/debug-web-platform-tests-wdspec-e10s-1",
     "test-linux1804-64/debug-reftest-no-accel-e10s-3",
     "test-windows7-32-shippable/opt-raptor-tp6-firefox-cold-docs-e10s",
     "test-macosx1014-64/debug-mochitest-media-gli-e10s-2",
     "test-linux64-shippable/opt-raptor-assorted-dom-firefox-e10s",
@@ -2863,17 +2862,16 @@
     "test-macosx1014-64-shippable/opt-raptor-tp6-firefox-cold-netflix-e10s",
     "test-windows10-64-qr/debug-crashtest-e10s",
     "source-test-python-raptor-windows10-64/opt-py3",
     "test-android-hw-p2-8-0-android-aarch64-shippable/opt-browsertime-tp6m-geckoview-cold-cnn-ampstories-e10s",
     "test-linux64-shippable-qr/opt-raptor-tp6-firefox-cold-imgur-e10s",
     "test-windows10-64/debug-web-platform-tests-reftest-e10s-5",
     "test-macosx1014-64-shippable/opt-mochitest-webgl2-ext-gli-e10s-2",
     "test-linux1804-64-qr/debug-web-platform-tests-reftest-e10s-1",
-    "test-windows10-64/debug-marionette-gpu-e10s",
     "test-linux64-shippable-qr/opt-raptor-tp6-firefox-cold-yandex-e10s",
     "test-windows10-64-shippable/opt-raptor-tp6-firefox-cold-linkedin-e10s",
     "test-linux64-shippable/opt-talos-g1-e10s",
     "test-windows10-64-shippable-qr/opt-raptor-tp6-firefox-cold-yahoo-mail-e10s",
     "test-linux1804-64/opt-web-platform-tests-print-reftest-e10s",
     "source-test-python-mozrelease-py3",
     "test-macosx1014-64/debug-mochitest-chrome-gpu-e10s",
     "test-windows10-64-shippable/opt-raptor-tp6-firefox-cold-yahoo-mail-e10s",
@@ -4265,17 +4263,16 @@
     "test-windows10-64/opt-mochitest-browser-chrome-e10s-2",
     "test-windows10-64-shippable-qr/opt-talos-perf-reftest-singletons-e10s",
     "test-android-em-7.0-x86_64/debug-geckoview-junit-e10s-multi-e10s",
     "test-windows10-64-qr/debug-mochitest-plain-e10s-3",
     "test-android-hw-p2-8-0-android-aarch64-qr/debug-geckoview-reftest-qr-e10s-2",
     "test-android-em-7.0-x86_64/debug-geckoview-web-platform-tests-reftest-e10s-2",
     "test-linux1804-64-asan/opt-web-platform-tests-e10s-1",
     "test-linux1804-64-asan/opt-mochitest-webgpu-e10s",
-    "test-windows10-64/opt-marionette-gpu-e10s",
     "test-windows10-64-qr/opt-web-platform-tests-print-reftest-e10s",
     "test-linux1804-64-qr/debug-reftest-fis-e10s-1",
     "test-linux1804-64-asan/opt-mochitest-plain-e10s-6",
     "test-vismet-android-hw-g5-7-0-arm7-api-16-shippable/opt-browsertime-tp6m-geckoview-cold-imdb",
     "test-windows10-64/debug-mochitest-webgl2-ext-e10s-2",
     "test-linux64-shippable/opt-raptor-tp6-firefox-cold-tumblr-e10s",
     "test-linux1804-64-qr/debug-web-platform-tests-reftest-e10s-2",
     "test-linux1804-64/opt-mochitest-webgl2-ext-e10s-1",
deleted file mode 100644
--- a/testing/marionette/harness/marionette_harness/tests/gpu-unit-tests.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-# graphics tests
-[include:../../../../../gfx/tests/marionette/manifest.ini]