Backed out 3 changesets (bug 1503776) for xperf failures
authorNarcis Beleuzu <nbeleuzu@mozilla.com>
Wed, 21 Nov 2018 01:38:34 +0200
changeset 503825 af4aa01c64c52f2aa5c9eecd48b4a7cfc2bd1abd
parent 503824 f5dfe72df46786a1683699c3d78208a28d739527
child 503826 e27269b076334ddd520fcbab374b584942b886f2
push id10290
push userffxbld-merge
push dateMon, 03 Dec 2018 16:23:23 +0000
treeherdermozilla-beta@700bed2445e6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1503776
milestone65.0a1
backs out596f70b5d5b0671a10957d57504be517a6da0a4b
2d2d1dfd04d491c928eaf2bfc3ceb504204b2cc3
3eb49d9e73bb4db202f6c8bb8bda4e9d89d34990
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
Backed out 3 changesets (bug 1503776) for xperf failures Backed out changeset 596f70b5d5b0 (bug 1503776) Backed out changeset 2d2d1dfd04d4 (bug 1503776) Backed out changeset 3eb49d9e73bb (bug 1503776)
gfx/tests/marionette/manifest.ini
gfx/tests/marionette/test_pref_rollout_workaround.py
gfx/tests/moz.build
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxPrefs.h
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
testing/marionette/harness/marionette_harness/tests/gpu-unit-tests.ini
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,111 +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 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 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 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, 'opt-in', 'Should start out as WR opt-in')
-        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, 'blocked', 'WR rolled out on non-qualifying hardware should be blocked.')
-        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, 'opt-in', 'WR rollback of rollout should revert to opt-in on non-qualifying hardware.')
-        self.assertTrue(compositor != 'webrender', 'After roll back on non-qualifying HW, WR should not be used.')
-
-
-    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, 'opt-in', 'Should start out as WR opt-in')
-        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, 'opt-in', 'WR rollback of rollout should revert to opt-in 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/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -762,94 +762,16 @@ WebRenderMemoryReporter::CollectReports(
     [](mozilla::ipc::ResponseRejectReason aReason) {
       FinishAsyncMemoryReport();
     }
   );
 
   return NS_OK;
 }
 
-static const char* const WR_ROLLOUT_PREF = "gfx.webrender.all.qualified";
-static const char* const WR_ROLLOUT_PREF_DEFAULT =
-  "gfx.webrender.all.qualified.default";
-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 : 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_PREF_DEFAULT, defaultValue);
-  }
-};
-
-NS_IMPL_ISUPPORTS(WrRolloutPrefShutdownSaver, nsIObserver)
 
 void
 gfxPlatform::Init()
 {
     MOZ_RELEASE_ASSERT(!XRE_IsGPUProcess(), "GFX: Not allowed in GPU process.");
     MOZ_RELEASE_ASSERT(!XRE_IsRDDProcess(), "GFX: Not allowed in RDD process.");
     MOZ_RELEASE_ASSERT(NS_IsMainThread(), "GFX: Not in main thread.");
 
@@ -886,20 +808,16 @@ gfxPlatform::Init()
         gfxVars::SetGREDirectory(nsString());
       } else {
         nsAutoString path;
         file->GetPath(path);
         gfxVars::SetGREDirectory(nsString(path));
       }
     }
 
-    if (XRE_IsParentProcess()) {
-      WrRolloutPrefShutdownSaver::AddShutdownObserver();
-    }
-
     // Drop a note in the crash report if we end up forcing an option that could
     // destabilize things.  New items should be appended at the end (of an existing
     // or in a new section), so that we don't have to know the version to interpret
     // these cryptic strings.
     {
       nsAutoCString forcedPrefs;
       // D2D prefs
       forcedPrefs.AppendPrintf("FP(D%d%d",
@@ -2770,79 +2688,58 @@ gfxPlatform::WebRenderPrefEnabled()
 
 /*static*/ bool
 gfxPlatform::WebRenderEnvvarEnabled()
 {
   const char* env = PR_GetEnv("MOZ_WEBRENDER");
   return (env && *env == '1');
 }
 
-// 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
-CalculateWrQualifiedPrefValue()
+void
+gfxPlatform::InitWebRenderConfig()
 {
-  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_PREF_DEFAULT);
-  });
-
-  if (!Preferences::HasUserValue(WR_ROLLOUT_PREF) &&
-      Preferences::HasUserValue(WR_ROLLOUT_PREF_DEFAULT)) {
-    // The user has not set a user pref, and we have a default value set by the
-    // shutdown observer. We should use that instead of the gfxPref's default,
-    // as if Normandy had a chance to set it before startup, that is the value
-    // gfxPrefs would return, rather than the default set by DECL_GFX_PREF.
-    return gfxPrefs::WebRenderAllQualifiedDefault();
+  bool prefEnabled = WebRenderPrefEnabled();
+  bool envvarEnabled = WebRenderEnvvarEnabled();
+
+  // On Nightly:
+  //   WR? WR+   => means WR was enabled via gfx.webrender.all.qualified
+  //   WR! WR+   => means WR was enabled via gfx.webrender.{all,enabled} or envvar
+  // On Beta/Release:
+  //   WR? WR+   => means WR was enabled via gfx.webrender.all.qualified on qualified hardware
+  //   WR! WR+   => means WR was enabled via envvar, possibly on unqualified hardware.
+  // In all cases WR- means WR was not enabled, for one of many possible reasons.
+  ScopedGfxFeatureReporter reporter("WR", prefEnabled || envvarEnabled);
+  if (!XRE_IsParentProcess()) {
+    // Force-disable WebRender in recording/replaying child processes, which
+    // have their own compositor.
+    if (recordreplay::IsRecordingOrReplaying()) {
+      gfxVars::SetUseWebRender(false);
+    }
+
+    // The parent process runs through all the real decision-making code
+    // later in this function. For other processes we still want to report
+    // the state of the feature for crash reports.
+    if (gfxVars::UseWebRender()) {
+      reporter.SetSuccessful();
+    }
+    return;
   }
 
-  // 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 whatever default is stored in the gfxPref. *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.
-  if (Preferences::HasUserValue(WR_ROLLOUT_PREF_OVERRIDE)) {
-    return Preferences::GetBool(WR_ROLLOUT_PREF_OVERRIDE);
-  }
-  return gfxPrefs::WebRenderAllQualified();
-}
-
-static FeatureState&
-WebRenderHardwareQualificationStatus(bool aHasBattery, nsCString& aOutFailureId)
-{
   FeatureState& featureWebRenderQualified = gfxConfig::GetFeature(Feature::WEBRENDER_QUALIFIED);
   featureWebRenderQualified.EnableByDefault();
-
-  if (Preferences::HasUserValue(WR_ROLLOUT_HW_QUALIFIED_OVERRIDE)) {
-    if (!Preferences::GetBool(WR_ROLLOUT_HW_QUALIFIED_OVERRIDE)) {
-      featureWebRenderQualified.Disable(
-        FeatureStatus::Blocked,
-        "HW qualification pref override",
-        NS_LITERAL_CSTRING("FEATURE_FAILURE_WR_QUALIFICATION_OVERRIDE"));
-    }
-    return featureWebRenderQualified;
-  }
-
   nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
+  nsCString failureId;
   int32_t status;
-  if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(
-        nsIGfxInfo::FEATURE_WEBRENDER, aOutFailureId, &status))) {
+  if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRENDER,
+                                             failureId, &status))) {
     if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
-      featureWebRenderQualified.Disable(
-        FeatureStatus::Blocked, "No qualified hardware", aOutFailureId);
-    } else if (aHasBattery) {
+      featureWebRenderQualified.Disable(FeatureStatus::Blocked,
+                                         "No qualified hardware",
+                                         failureId);
+    } else if (HasBattery()) {
       featureWebRenderQualified.Disable(FeatureStatus::Blocked,
                                          "Has battery",
                                          NS_LITERAL_CSTRING("FEATURE_FAILURE_WR_HAS_BATTERY"));
     } else {
       nsAutoString adapterVendorID;
       gfxInfo->GetAdapterVendorID(adapterVendorID);
       if (adapterVendorID != u"0x10de") {
         featureWebRenderQualified.Disable(FeatureStatus::Blocked,
@@ -2866,75 +2763,38 @@ WebRenderHardwareQualificationStatus(boo
         }
       }
     }
   } else {
     featureWebRenderQualified.Disable(FeatureStatus::Blocked,
                                        "gfxInfo is broken",
                                        NS_LITERAL_CSTRING("FEATURE_FAILURE_WR_NO_GFX_INFO"));
   }
-  return featureWebRenderQualified;
-}
-
-void
-gfxPlatform::InitWebRenderConfig()
-{
-  bool prefEnabled = WebRenderPrefEnabled();
-  bool envvarEnabled = WebRenderEnvvarEnabled();
-
-  // On Nightly:
-  //   WR? WR+   => means WR was enabled via gfx.webrender.all.qualified
-  //   WR! WR+   => means WR was enabled via gfx.webrender.{all,enabled} or envvar
-  // On Beta/Release:
-  //   WR? WR+   => means WR was enabled via gfx.webrender.all.qualified on qualified hardware
-  //   WR! WR+   => means WR was enabled via envvar, possibly on unqualified hardware.
-  // In all cases WR- means WR was not enabled, for one of many possible reasons.
-  ScopedGfxFeatureReporter reporter("WR", prefEnabled || envvarEnabled);
-  if (!XRE_IsParentProcess()) {
-    // Force-disable WebRender in recording/replaying child processes, which
-    // have their own compositor.
-    if (recordreplay::IsRecordingOrReplaying()) {
-      gfxVars::SetUseWebRender(false);
-    }
-
-    // The parent process runs through all the real decision-making code
-    // later in this function. For other processes we still want to report
-    // the state of the feature for crash reports.
-    if (gfxVars::UseWebRender()) {
-      reporter.SetSuccessful();
-    }
-    return;
-  }
-
-  nsCString failureId;
-  FeatureState& featureWebRenderQualified =
-    WebRenderHardwareQualificationStatus(HasBattery(), failureId);
+
   FeatureState& featureWebRender = gfxConfig::GetFeature(Feature::WEBRENDER);
 
   featureWebRender.DisableByDefault(
       FeatureStatus::OptIn,
       "WebRender is an opt-in feature",
       NS_LITERAL_CSTRING("FEATURE_FAILURE_DEFAULT_OFF"));
 
-  const bool wrQualifiedAll = CalculateWrQualifiedPrefValue();
-
   // envvar works everywhere; we need this for testing in CI. Sadly this allows
   // beta/release to enable it on unqualified hardware, but at least this is
   // harder for the average person than flipping a pref.
   if (envvarEnabled) {
     featureWebRender.UserEnable("Force enabled by envvar");
 
   // gfx.webrender.enabled and gfx.webrender.all only work on nightly
 #ifdef NIGHTLY_BUILD
   } else if (prefEnabled) {
     featureWebRender.UserEnable("Force enabled by pref");
 #endif
 
   // gfx.webrender.all.qualified works on all channels
-  } else if (wrQualifiedAll) {
+  } else if (gfxPrefs::WebRenderAllQualified()) {
     if (featureWebRenderQualified.IsEnabled()) {
       featureWebRender.UserEnable("Qualified enabled by pref ");
     } else {
       featureWebRender.ForceDisable(FeatureStatus::Blocked,
                                     "Qualified enable blocked",
                                     failureId);
     }
   }
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -527,21 +527,16 @@ private:
   DECL_GFX_PREF(Once, "gfx.use-mutex-on-present",              UseMutexOnPresent, bool, false);
   DECL_GFX_PREF(Once, "gfx.use-surfacetexture-textures",       UseSurfaceTextureTextures, bool, false);
   DECL_GFX_PREF(Once, "gfx.allow-texture-direct-mapping",      AllowTextureDirectMapping, bool, true);
   DECL_GFX_PREF(Live, "gfx.vsync.collect-scroll-transforms",   CollectScrollTransforms, bool, false);
   DECL_GFX_PREF(Once, "gfx.vsync.compositor.unobserve-count",  CompositorUnobserveCount, int32_t, 10);
 
   DECL_GFX_PREF(Once, "gfx.webrender.all",                     WebRenderAll, bool, false);
   DECL_GFX_PREF(Once, "gfx.webrender.all.qualified",           WebRenderAllQualified, bool, true);
-  DECL_GFX_PREF(Once,
-                "gfx.webrender.all.qualified.default",
-                WebRenderAllQualifiedDefault,
-                bool,
-                false);
   DECL_GFX_PREF(Live, "gfx.webrender.blob-images",             WebRenderBlobImages, bool, true);
   DECL_GFX_PREF(Live, "gfx.webrender.blob.invalidation",       WebRenderBlobInvalidation, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.blob.paint-flashing",     WebRenderBlobPaintFlashing, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.dl.dump-parent",          WebRenderDLDumpParent, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.dl.dump-content",         WebRenderDLDumpContent, bool, false);
   DECL_GFX_PREF(Once, "gfx.webrender.enabled",                 WebRenderEnabledDoNotUseDirectly, bool, false);
   DECL_GFX_PREF(Once, "gfx.webrender.force-disabled",          WebRenderForceDisabled, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.highlight-painted-layers",WebRenderHighlightPaintedLayers, bool, false);
--- a/python/mozbuild/mozbuild/action/test_archive.py
+++ b/python/mozbuild/mozbuild/action/test_archive.py
@@ -134,17 +134,16 @@ ARCHIVE_FILES = {
                 'puppeteer/firefox/docs',
             ],
         },
         {
             '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
@@ -1850,20 +1850,16 @@ VARIABLES = {
     'PUPPETEER_FIREFOX_MANIFESTS': (ManifestparserManifestList, list,
         """List of manifest files defining puppeteer unit tests for Firefox.
         """),
 
     '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, list,
         """List of manifest files defining metro browser chrome tests.
         """),
 
--- a/taskcluster/ci/test/marionette.yml
+++ b/taskcluster/ci/test/marionette.yml
@@ -42,21 +42,8 @@ marionette:
 marionette-headless:
     description: "Marionette headless unittest run"
     treeherder-symbol: MnH
     max-run-time: 5400
     instance-size: default
     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
-    virtualization:
-        by-test-platform:
-            windows10-64.*: virtual-with-gpu
-            default: virtual
--- a/taskcluster/ci/test/test-platforms.yml
+++ b/taskcluster/ci/test/test-platforms.yml
@@ -168,69 +168,62 @@ windows7-32-devedition/opt:
 # win64
 windows10-64-ccov/debug:
     build-platform: win64-ccov/debug
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - windows-reftest-gpu
         - windows-talos
-        - marionette-gpu-tests
         - windows-tests
         - ccov-code-coverage-tests
 
 windows10-64/debug:
     build-platform: win64/debug
     test-sets:
-        - marionette-gpu-tests
         - windows-tests
         - mochitest-headless
 
 windows10-64/opt:
     build-platform: win64/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - windows-talos
-        - marionette-gpu-tests
         - windows-tests
         - mochitest-headless
         - raptor-firefox
 
 windows10-64-ux/opt:
     build-platform: win64-nightly/opt
     test-sets:
         - raptor-firefox
 
 windows10-64-pgo/opt:
     build-platform: win64-pgo/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
-        - marionette-gpu-tests
         - windows-talos
-        - marionette-gpu-tests
         - windows-tests
         - raptor-firefox
 
 windows10-64-nightly/opt:
     build-platform: win64-nightly/opt
     test-sets:
         - awsy
         - desktop-screenshot-capture
         - desktop-instrumentation
-        - marionette-gpu-tests
         - windows-tests
         - raptor-chrome
 
 windows10-64-devedition/opt:
     build-platform: win64-devedition-nightly/opt
     test-sets:
         - desktop-screenshot-capture
-        - marionette-gpu-tests
         - windows-tests
 
 windows10-64-asan/opt:
     build-platform: win64-asan/opt
     test-sets:
         - common-tests
 
 # QR builds just run a subset right now.
--- a/taskcluster/ci/test/test-sets.yml
+++ b/taskcluster/ci/test/test-sets.yml
@@ -218,19 +218,16 @@ windows-talos:
     - talos-perf-reftest
     - talos-perf-reftest-singletons
     - talos-svgr
     - talos-tp5o
     - talos-xperf
     - talos-tps
     # - talos-h1 Bug 1487031 - Disabled for not finding actionable regressions
 
-marionette-gpu-tests:
-    - marionette-gpu
-
 macosx64-tests:
     - cppunit
     - crashtest
     - firefox-ui-functional-local
     - firefox-ui-functional-remote
     - gtest
     - jittest
     - jsreftest
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]