--- a/devtools/client/netmonitor/src/assets/styles/NetworkDetailsPanel.css
+++ b/devtools/client/netmonitor/src/assets/styles/NetworkDetailsPanel.css
@@ -178,22 +178,27 @@
 .network-monitor .headers-summary-label,
 .network-monitor .tree-container .objectBox {
   white-space: nowrap;
 }
 
 /* Summary tabpanel */
 
 .network-monitor .tabpanel-summary-container {
+  flex-wrap: wrap;
   padding: 1px;
+  padding-inline-start: 4px;
+}
+
+.network-monitor .tabpanel-summary-labelvalue {
+  white-space: pre-wrap;
 }
 
 .network-monitor .tabpanel-summary-label {
   display: inline-block;
-  padding-inline-start: 4px;
   padding-inline-end: 3px;
   font-weight: 600;
 }
 
 .network-monitor .tabpanel-summary-value {
   color: inherit;
   padding-inline-start: 3px;
 }

--- a/devtools/client/netmonitor/src/components/HeadersPanel.js
+++ b/devtools/client/netmonitor/src/components/HeadersPanel.js
@@ -120,24 +120,24 @@ class HeadersPanel extends Component {
     this.setState({
       rawHeadersOpened: !this.state.rawHeadersOpened,
     });
   }
 
   renderSummary(label, value) {
     return (
       div({ className: "tabpanel-summary-container headers-summary" },
-        div({
-          className: "tabpanel-summary-label headers-summary-label",
-        }, label),
-        input({
-          className: "tabpanel-summary-value textbox-input devtools-monospace",
-          readOnly: true,
-          value,
-        }),
+        div({ className: "tabpanel-summary-labelvalue"},
+          span({ className: "tabpanel-summary-label headers-summary-label"},
+            label
+          ),
+          span({ className: "tabpanel-summary-value textbox-input devtools-monospace"},
+            value
+          ),
+        ),
       )
     );
   }
 
   renderValue(props) {
     const member = props.member;
     const value = props.value;
 

--- a/devtools/client/netmonitor/test/browser_net_header-ref-policy.js
+++ b/devtools/client/netmonitor/test/browser_net_header-ref-policy.js
@@ -28,13 +28,13 @@ add_task(async function() {
   const referrerPolicyHeader
     = document.querySelectorAll(".tabpanel-summary-label")[referrerPolicyIndex];
   const referrerPolicyValue
     = document.querySelectorAll(".tabpanel-summary-value")[referrerPolicyIndex];
 
   is(referrerPolicyHeader.textContent === "Referrer Policy:",
   true, "\"Referrer Policy\" header is displayed in the header panel.");
 
-  is(referrerPolicyValue.value === "no-referrer-when-downgrade",
+  is(referrerPolicyValue.textContent === "no-referrer-when-downgrade",
   true, "The referrer policy value is reflected correctly.");
 
   return teardown(monitor);
 });

--- a/devtools/client/netmonitor/test/browser_net_status-codes.js
+++ b/devtools/client/netmonitor/test/browser_net_status-codes.js
@@ -175,19 +175,19 @@ add_task(async function() {
     const panel = document.querySelector("#headers-panel");
     const summaryValues = panel.querySelectorAll(".tabpanel-summary-value.textbox-input");
     const { method, correctUri, details: { status, statusText } } = data;
     const statusCode = panel.querySelector(".status-code");
     const statusTextInput = panel.querySelector(".status-text");
     EventUtils.sendMouseEvent({ type: "mouseover" }, statusCode);
     await waitUntil(() => statusCode.title);
 
-    is(summaryValues[0].value, correctUri,
+    is(summaryValues[0].textContent, correctUri,
       "The url summary value is incorrect.");
-    is(summaryValues[1].value, method, "The method summary value is incorrect.");
+    is(summaryValues[1].textContent, method, "The method summary value is incorrect.");
     is(statusCode.dataset.code, status,
       "The status summary code is incorrect.");
     is(statusCode.getAttribute("title"), status + " " + statusText,
       "The status summary value is incorrect.");
     is(statusTextInput.value, statusText, "The status text value is incorrect.");
   }
 
   /**

--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -6709,25 +6709,29 @@ AutoHeapSession::~AutoHeapSession() {
   runtime->heapState_ = prevState;
 }
 
 JS_PUBLIC_API JS::HeapState JS::RuntimeHeapState() {
   return TlsContext.get()->runtime()->heapState();
 }
 
 GCRuntime::IncrementalResult GCRuntime::resetIncrementalGC(
-    gc::AbortReason reason, AutoGCSession& session) {
-  MOZ_ASSERT(reason != gc::AbortReason::None);
+    gc::AbortReason reason) {
+  if (incrementalState == State::NotActive) {
+    return IncrementalResult::Ok;
+  }
+
+  minorGC(JS::gcreason::RESET, gcstats::PhaseKind::EVICT_NURSERY_FOR_MAJOR_GC);
+
+  AutoGCSession session(rt, JS::HeapState::MajorCollecting);
 
   switch (incrementalState) {
     case State::NotActive:
-      return IncrementalResult::Ok;
-
     case State::MarkRoots:
-      MOZ_CRASH("resetIncrementalGC did not expect MarkRoots state");
+      MOZ_CRASH("Unexpected GC state in resetIncrementalGC");
       break;
 
     case State::Mark: {
       /* Cancel any ongoing marking. */
       marker.reset();
       marker.stop();
       clearBufferedGrayRoots();
 
@@ -6909,16 +6913,18 @@ static bool ShouldCleanUpEverything(JS::
 }
 
 GCRuntime::IncrementalResult GCRuntime::incrementalSlice(
     SliceBudget& budget, JS::gcreason::Reason reason, AutoGCSession& session) {
   AutoDisableBarriers disableBarriers(rt);
 
   bool destroyingRuntime = (reason == JS::gcreason::DESTROY_RUNTIME);
 
+  number++;
+
   initialState = incrementalState;
 
 #ifdef JS_GC_ZEAL
   /*
    * Do the incremental collection type specified by zeal mode if the
    * collection was triggered by runDebugGC() and incremental GC has not been
    * cancelled by resetIncrementalGC().
    */
@@ -6954,16 +6960,17 @@ GCRuntime::IncrementalResult GCRuntime::
      * the budget is not used.
      */
     stats().writeLogMessage("Using unlimited budget for two-slice zeal mode");
     budget.makeUnlimited();
   }
 
   switch (incrementalState) {
     case State::NotActive:
+      incMajorGcNumber();
       initialReason = reason;
       cleanUpEverything = ShouldCleanUpEverything(reason, invocationKind);
       isCompacting = shouldCompact();
       MOZ_ASSERT(!lastMarkSlice);
       rootsRemoved = false;
 
       incrementalState = State::MarkRoots;
 
@@ -7029,41 +7036,25 @@ GCRuntime::IncrementalResult GCRuntime::
              !(useZeal && hasZealMode(ZealMode::YieldBeforeMarking))) ||
             (useZeal && hasZealMode(ZealMode::YieldBeforeSweeping))) {
           lastMarkSlice = true;
           stats().writeLogMessage("Yielding before starting sweeping");
           break;
         }
       }
 
-      /*
-       * If the nursery is not-empty we need to collect it before sweeping.
-       *
-       * This can happen regardless of 'isIncremental' since the GC may have
-       * been incremental when it started and later made a decision to do
-       * non-incremental collection.
-       *
-       * It's important to check this after the above case since this one
-       * wont give the mutator a chance to run.
-       */
-      if (!nursery().isEmpty()) {
-        lastMarkSlice = true;
-        stats().writeLogMessage(
-            "returning to collect the nursery before sweeping");
-        return IncrementalResult::ReturnToEvictNursery;
-      }
-
       incrementalState = State::Sweep;
       lastMarkSlice = false;
       beginSweepPhase(reason, session);
 
       MOZ_FALLTHROUGH;
 
     case State::Sweep:
       MOZ_ASSERT(nursery().isEmpty());
+      storeBuffer().checkEmpty();
 
       AutoGCRooter::traceAllWrappers(rt->mainContextFromOwnThread(), &marker);
 
       if (performSweepActions(budget) == NotFinished) {
         break;
       }
 
       endSweepPhase(destroyingRuntime);
@@ -7103,16 +7094,19 @@ GCRuntime::IncrementalResult GCRuntime::
       // Always yield before compacting since it is not incremental.
       if (isCompacting && !budget.isUnlimited()) {
         break;
       }
 
       MOZ_FALLTHROUGH;
 
     case State::Compact:
+      MOZ_ASSERT(nursery().isEmpty());
+      storeBuffer().checkEmpty();
+
       if (isCompacting) {
         MOZ_ASSERT(nursery().isEmpty());
         if (!startedCompacting) {
           beginCompactPhase();
         }
 
         if (compactPhase(reason, budget, session) == NotFinished) {
           break;
@@ -7176,53 +7170,52 @@ static inline void CheckZoneIsScheduled(
             zone->isGCScheduled() ? " scheduled" : "");
   }
   fflush(stderr);
   MOZ_CRASH("Zone not scheduled");
 #endif
 }
 
 GCRuntime::IncrementalResult GCRuntime::budgetIncrementalGC(
-    bool nonincrementalByAPI, JS::gcreason::Reason reason, SliceBudget& budget,
-    AutoGCSession& session) {
+    bool nonincrementalByAPI, JS::gcreason::Reason reason,
+    SliceBudget& budget) {
   if (nonincrementalByAPI) {
     stats().nonincremental(gc::AbortReason::NonIncrementalRequested);
     budget.makeUnlimited();
 
     // Reset any in progress incremental GC if this was triggered via the
     // API. This isn't required for correctness, but sometimes during tests
     // the caller expects this GC to collect certain objects, and we need
     // to make sure to collect everything possible.
     if (reason != JS::gcreason::ALLOC_TRIGGER) {
-      return resetIncrementalGC(gc::AbortReason::NonIncrementalRequested,
-                                session);
+      return resetIncrementalGC(gc::AbortReason::NonIncrementalRequested);
     }
 
     return IncrementalResult::Ok;
   }
 
   if (reason == JS::gcreason::ABORT_GC) {
     budget.makeUnlimited();
     stats().nonincremental(gc::AbortReason::AbortRequested);
-    return resetIncrementalGC(gc::AbortReason::AbortRequested, session);
+    return resetIncrementalGC(gc::AbortReason::AbortRequested);
   }
 
   AbortReason unsafeReason = IsIncrementalGCUnsafe(rt);
   if (unsafeReason == AbortReason::None) {
     if (reason == JS::gcreason::COMPARTMENT_REVIVED) {
       unsafeReason = gc::AbortReason::CompartmentRevived;
     } else if (mode != JSGC_MODE_INCREMENTAL) {
       unsafeReason = gc::AbortReason::ModeChange;
     }
   }
 
   if (unsafeReason != AbortReason::None) {
     budget.makeUnlimited();
     stats().nonincremental(unsafeReason);
-    return resetIncrementalGC(unsafeReason, session);
+    return resetIncrementalGC(unsafeReason);
   }
 
   if (mallocCounter.shouldTriggerGC(tunables) == NonIncrementalTrigger) {
     budget.makeUnlimited();
     stats().nonincremental(AbortReason::MallocBytesTrigger);
   }
 
   bool reset = false;
@@ -7245,17 +7238,17 @@ GCRuntime::IncrementalResult GCRuntime::
 
     if (isIncrementalGCInProgress() &&
         zone->isGCScheduled() != zone->wasGCStarted()) {
       reset = true;
     }
   }
 
   if (reset) {
-    return resetIncrementalGC(AbortReason::ZoneChange, session);
+    return resetIncrementalGC(AbortReason::ZoneChange);
   }
 
   return IncrementalResult::Ok;
 }
 
 namespace {
 
 class AutoScheduleZonesForGC {
@@ -7345,42 +7338,45 @@ void GCRuntime::maybeCallGCCallback(JSGC
 /*
  * We disable inlining to ensure that the bottom of the stack with possible GC
  * roots recorded in MarkRuntime excludes any pointers we use during the marking
  * implementation.
  */
 MOZ_NEVER_INLINE GCRuntime::IncrementalResult GCRuntime::gcCycle(
     bool nonincrementalByAPI, SliceBudget& budget,
     JS::gcreason::Reason reason) {
+  // Assert if this is a GC unsafe region.
+  rt->mainContextFromOwnThread()->verifyIsSafeToGC();
+
+  // It's ok if threads other than the main thread have suppressGC set, as
+  // they are operating on zones which will not be collected from here.
+  MOZ_ASSERT(!rt->mainContextFromOwnThread()->suppressGC);
+
   // Note that GC callbacks are allowed to re-enter GC.
   AutoCallGCCallbacks callCallbacks(*this);
 
   gcstats::AutoGCSlice agc(stats(), scanZonesBeforeGC(), invocationKind, budget,
                            reason);
 
+  auto result = budgetIncrementalGC(nonincrementalByAPI, reason, budget);
+
+  // If an ongoing incremental GC was reset, we may need to restart.
+  if (result == IncrementalResult::ResetIncremental) {
+    MOZ_ASSERT(!isIncrementalGCInProgress());
+    return result;
+  }
+
   if (shouldCollectNurseryForSlice(nonincrementalByAPI, budget)) {
     minorGC(reason, gcstats::PhaseKind::EVICT_NURSERY_FOR_MAJOR_GC);
   }
 
   AutoGCSession session(rt, JS::HeapState::MajorCollecting);
 
   majorGCTriggerReason = JS::gcreason::NO_REASON;
 
-  number++;
-  if (!isIncrementalGCInProgress()) {
-    incMajorGcNumber();
-  }
-
-  // It's ok if threads other than the main thread have suppressGC set, as
-  // they are operating on zones which will not be collected from here.
-  MOZ_ASSERT(!rt->mainContextFromOwnThread()->suppressGC);
-
-  // Assert if this is a GC unsafe region.
-  rt->mainContextFromOwnThread()->verifyIsSafeToGC();
-
   {
     gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::WAIT_BACKGROUND_THREAD);
 
     // Background finalization and decommit are finished by defininition
     // before we can start a new GC session.
     if (!isIncrementalGCInProgress()) {
       assertBackgroundSweepingFinished();
       MOZ_ASSERT(!decommitTask.isRunning());
@@ -7394,25 +7390,16 @@ MOZ_NEVER_INLINE GCRuntime::IncrementalR
   }
 
   // We don't allow off-thread parsing to start while we're doing an
   // incremental GC of the atoms zone.
   if (rt->activeGCInAtomsZone()) {
     session.maybeCheckAtomsAccess.emplace(rt);
   }
 
-  auto result =
-      budgetIncrementalGC(nonincrementalByAPI, reason, budget, session);
-
-  // If an ongoing incremental GC was reset, we may need to restart.
-  if (result == IncrementalResult::ResetIncremental) {
-    MOZ_ASSERT(!isIncrementalGCInProgress());
-    return result;
-  }
-
   gcTracer.traceMajorGCStart();
 
   result = incrementalSlice(budget, reason, session);
 
   chunkAllocationSinceLastGC = false;
 
 #ifdef JS_GC_ZEAL
   /* Keeping these around after a GC is dangerous. */
@@ -7600,19 +7587,16 @@ void GCRuntime::collect(bool nonincremen
         /* Need to re-schedule all zones for GC. */
         JS::PrepareForFullGC(rt->mainContextFromOwnThread());
         repeat = true;
         reason = JS::gcreason::ROOTS_REMOVED;
       } else if (shouldRepeatForDeadZone(reason)) {
         repeat = true;
         reason = JS::gcreason::COMPARTMENT_REVIVED;
       }
-    } else if (cycleResult == ReturnToEvictNursery) {
-      /* Repeat so we can collect the nursery and run another slice. */
-      repeat = true;
     }
   } while (repeat);
 
   if (reason == JS::gcreason::COMPARTMENT_REVIVED) {
     maybeDoCycleCollection();
   }
 
 #ifdef JS_GC_ZEAL

--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -521,17 +521,17 @@ class GCRuntime {
   void startTask(GCParallelTask& task, gcstats::PhaseKind phase,
                  AutoLockHelperThreadState& locked);
   void joinTask(GCParallelTask& task, gcstats::PhaseKind phase,
                 AutoLockHelperThreadState& locked);
 
   void mergeRealms(JS::Realm* source, JS::Realm* target);
 
  private:
-  enum IncrementalResult { ResetIncremental = 0, ReturnToEvictNursery, Ok };
+  enum IncrementalResult { ResetIncremental = 0, Ok };
 
   // Delete an empty zone after its contents have been merged.
   void deleteEmptyZone(Zone* zone);
 
   // For ArenaLists::allocateFromArena()
   friend class ArenaLists;
   Chunk* pickChunk(AutoLockGCBgAlloc& lock);
   Arena* allocateArena(Chunk* chunk, Zone* zone, AllocKind kind,
@@ -561,20 +561,18 @@ class GCRuntime {
   friend class BackgroundAllocTask;
   bool wantBackgroundAllocation(const AutoLockGC& lock) const;
   bool startBackgroundAllocTaskIfIdle();
 
   void requestMajorGC(JS::gcreason::Reason reason);
   SliceBudget defaultBudget(JS::gcreason::Reason reason, int64_t millis);
   IncrementalResult budgetIncrementalGC(bool nonincrementalByAPI,
                                         JS::gcreason::Reason reason,
-                                        SliceBudget& budget,
-                                        AutoGCSession& session);
-  IncrementalResult resetIncrementalGC(AbortReason reason,
-                                       AutoGCSession& session);
+                                        SliceBudget& budget);
+  IncrementalResult resetIncrementalGC(AbortReason reason);
 
   // Assert if the system state is such that we should never
   // receive a request to do GC work.
   void checkCanCallAPI();
 
   // Check if the system state is such that GC has been supressed
   // or otherwise delayed.
   MOZ_MUST_USE bool checkIfGCAllowedInCurrentState(JS::gcreason::Reason reason);
@@ -585,18 +583,16 @@ class GCRuntime {
 
   /*
    * Run one GC "cycle" (either a slice of incremental GC or an entire
    * non-incremental GC).
    *
    * Returns:
    *  * ResetIncremental if we "reset" an existing incremental GC, which would
    *    force us to run another cycle or
-   *  * ReturnToEvictNursery if the collector needs the nursery to be
-   *    evicted before it can continue or
    *  * Ok otherwise.
    */
   MOZ_MUST_USE IncrementalResult gcCycle(bool nonincrementalByAPI,
                                          SliceBudget& budget,
                                          JS::gcreason::Reason reason);
   bool shouldRepeatForDeadZone(JS::gcreason::Reason reason);
   IncrementalResult incrementalSlice(SliceBudget& budget,
                                      JS::gcreason::Reason reason,

--- a/js/src/gc/StoreBuffer.cpp
+++ b/js/src/gc/StoreBuffer.cpp
@@ -26,17 +26,17 @@ void StoreBuffer::GenericBuffer::trace(S
 
   for (LifoAlloc::Enum e(*storage_); !e.empty();) {
     unsigned size = *e.read<unsigned>();
     BufferableRef* edge = e.read<BufferableRef>(size);
     edge->trace(trc);
   }
 }
 
-inline void StoreBuffer::checkEmpty() const {
+void StoreBuffer::checkEmpty() const {
   MOZ_ASSERT(bufferVal.isEmpty());
   MOZ_ASSERT(bufferCell.isEmpty());
   MOZ_ASSERT(bufferSlot.isEmpty());
   MOZ_ASSERT(bufferWholeCell.isEmpty());
   MOZ_ASSERT(bufferGeneric.isEmpty());
 }
 
 bool StoreBuffer::enable() {

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/bad-strategies.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/bad-strategies.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/bad-strategies.js");
+load_web_platform_test("streams/readable-streams/bad-strategies.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/bad-underlying-sources.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/bad-underlying-sources.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/bad-underlying-sources.js");
+load_web_platform_test("streams/readable-streams/bad-underlying-sources.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/brand-checks.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/brand-checks.js
@@ -1,2 +1,3 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/brand-checks.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/readable-streams/brand-checks.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/cancel.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/cancel.js
@@ -1,2 +1,4 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/cancel.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/resources/rs-utils.js");
+load_web_platform_test("streams/readable-streams/cancel.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/constructor.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/constructor.js
@@ -1,2 +1,3 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/constructor.js");
+load_web_platform_test("streams/resources/constructor-ordering.js");
+load_web_platform_test("streams/readable-streams/constructor.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/count-queuing-strategy-integration.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/count-queuing-strategy-integration.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/count-queuing-strategy-integration.js");
+load_web_platform_test("streams/readable-streams/count-queuing-strategy-integration.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/default-reader.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/default-reader.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/default-reader.js");
+load_web_platform_test("streams/readable-streams/default-reader.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/floating-point-total-queue-size.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/floating-point-total-queue-size.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/floating-point-total-queue-size.js");
+load_web_platform_test("streams/readable-streams/floating-point-total-queue-size.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/garbage-collection.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/garbage-collection.js
@@ -1,2 +1,4 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/garbage-collection.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/resources/rs-utils.js");
+load_web_platform_test("streams/readable-streams/garbage-collection.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/general.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/general.js
@@ -20,9 +20,11 @@ Object.defineProperties(ReadableStream.p
     enumerable: false,
     value: function pipeThrough({writable, readable}, {preventClose, preventAbort, preventCancel, signal}) {
       throw new InternalError("pipeThrough: not implemented");
     },
   },
 });
 
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/general.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/resources/rs-utils.js");
+load_web_platform_test("streams/readable-streams/general.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/patched-global.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/patched-global.js
@@ -1,2 +1,2 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/patched-global.js");
+load_web_platform_test("streams/readable-streams/patched-global.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/reentrant-strategies.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/reentrant-strategies.js
@@ -1,4 +1,5 @@
-// |jit-test| error: ReferenceError: WritableStream is not defined
-
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/reentrant-strategies.js");
+load_web_platform_test("streams/resources/recording-streams.js");
+load_web_platform_test("streams/resources/rs-utils.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/readable-streams/reentrant-strategies.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/tee.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/tee.js
@@ -1,2 +1,3 @@
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/tee.js");
+load_web_platform_test("streams/resources/rs-utils.js");
+load_web_platform_test("streams/readable-streams/tee.any.js");

--- a/js/src/jit-test/tests/web-platform/streams/readable-streams/templated.js
+++ b/js/src/jit-test/tests/web-platform/streams/readable-streams/templated.js
@@ -20,9 +20,11 @@ Object.defineProperties(ReadableStream.p
     enumerable: false,
     value: function pipeThrough({writable, readable}, {preventClose, preventAbort, preventCancel, signal}) {
       throw new InternalError("pipeThrough: not implemented");
     },
   },
 });
 
 load(libdir + "web-platform-testharness.js");
-load_web_platform_test("streams/readable-streams/templated.js");
+load_web_platform_test("streams/resources/test-utils.js");
+load_web_platform_test("streams/resources/rs-test-templates.js");
+load_web_platform_test("streams/readable-streams/templated.any.js");

--- a/testing/web-platform/meta/FileAPI/url/sandboxed-iframe.html.ini
+++ b/testing/web-platform/meta/FileAPI/url/sandboxed-iframe.html.ini
@@ -16,8 +16,14 @@
     expected: FAIL
 
   [Appending a query string should cause fetch to fail]
     expected: FAIL
 
   [Revoke blob URL after creating Request, will fetch]
     expected: FAIL
 
+  [Blob URL fragment is implemented.]
+    expected: FAIL
+
+  [Blob URLs can be used in iframes, and are treated same origin]
+    expected: FAIL
+

--- a/testing/web-platform/meta/background-fetch/fetch.https.window.js.ini
+++ b/testing/web-platform/meta/background-fetch/fetch.https.window.js.ini
@@ -42,8 +42,11 @@
     expected: FAIL
 
   [Matching to a single request should work]
     expected: FAIL
 
   [Matching to a non-existing request should work]
     expected: FAIL
 
+  [Matching multiple times on the same request works as expected.]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/content-security-policy/inheritance/iframe-srcdoc-inheritance.html.ini
@@ -0,0 +1,8 @@
+[iframe-srcdoc-inheritance.html]
+  expected: TIMEOUT
+  [First image should be blocked]
+    expected: NOTRUN
+
+  [Second image should be blocked]
+    expected: NOTRUN
+

--- a/testing/web-platform/meta/content-security-policy/navigate-to/link-click-cross-origin-blocked.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/navigate-to/link-click-cross-origin-blocked.sub.html.ini
@@ -1,10 +1,12 @@
 [link-click-cross-origin-blocked.sub.html]
   [Test that the child iframe navigation is blocked]
     expected: FAIL
 
   [Violation report status OK.]
     expected: FAIL
 
   [Test that the child iframe navigation is not allowed]
-    expected: FAIL
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): NOTRUN
+      FAIL
 

--- a/testing/web-platform/meta/content-security-policy/navigate-to/link-click-redirected-blocked.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/navigate-to/link-click-redirected-blocked.sub.html.ini
@@ -1,10 +1,12 @@
 [link-click-redirected-blocked.sub.html]
   [Test that the child iframe navigation is blocked]
     expected: FAIL
 
   [Violation report status OK.]
     expected: FAIL
 
   [Test that the child iframe navigation is not allowed]
-    expected: FAIL
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): NOTRUN
+      FAIL
 

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/content-security-policy/navigation/to-javascript-parent-initiated-parent-csp.html.ini
@@ -0,0 +1,4 @@
+[to-javascript-parent-initiated-parent-csp.html]
+  [Should not have executed the javascript url]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/cookies/path/default.html.ini
@@ -0,0 +1,4 @@
+[default.html]
+  [Test for default cookie path]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-after-computed.html.ini
@@ -0,0 +1,22 @@
+[break-after-computed.html]
+  [Property break-after value 'verso' computes to 'verso']
+    expected: FAIL
+
+  [Property break-after value 'region' computes to 'region']
+    expected: FAIL
+
+  [Property break-after value 'column' computes to 'column']
+    expected: FAIL
+
+  [Property break-after value 'avoid-region' computes to 'avoid-region']
+    expected: FAIL
+
+  [Property break-after value 'avoid-page' computes to 'avoid-page']
+    expected: FAIL
+
+  [Property break-after value 'avoid-column' computes to 'avoid-column']
+    expected: FAIL
+
+  [Property break-after value 'recto' computes to 'recto']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-after-valid.html.ini
@@ -0,0 +1,22 @@
+[break-after-valid.html]
+  [e.style['break-after'\] = "avoid-column" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "avoid-region" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "verso" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "region" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "column" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "avoid-page" should set the property value]
+    expected: FAIL
+
+  [e.style['break-after'\] = "recto" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-before-computed.html.ini
@@ -0,0 +1,22 @@
+[break-before-computed.html]
+  [Property break-before value 'avoid-region' computes to 'avoid-region']
+    expected: FAIL
+
+  [Property break-before value 'region' computes to 'region']
+    expected: FAIL
+
+  [Property break-before value 'verso' computes to 'verso']
+    expected: FAIL
+
+  [Property break-before value 'recto' computes to 'recto']
+    expected: FAIL
+
+  [Property break-before value 'column' computes to 'column']
+    expected: FAIL
+
+  [Property break-before value 'avoid-column' computes to 'avoid-column']
+    expected: FAIL
+
+  [Property break-before value 'avoid-page' computes to 'avoid-page']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-before-valid.html.ini
@@ -0,0 +1,22 @@
+[break-before-valid.html]
+  [e.style['break-before'\] = "region" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "avoid-region" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "recto" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "avoid-column" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "avoid-page" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "verso" should set the property value]
+    expected: FAIL
+
+  [e.style['break-before'\] = "column" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-inside-computed.html.ini
@@ -0,0 +1,10 @@
+[break-inside-computed.html]
+  [Property break-inside value 'avoid-page' computes to 'avoid-page']
+    expected: FAIL
+
+  [Property break-inside value 'avoid-column' computes to 'avoid-column']
+    expected: FAIL
+
+  [Property break-inside value 'avoid-region' computes to 'avoid-region']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/break-inside-valid.html.ini
@@ -0,0 +1,10 @@
+[break-inside-valid.html]
+  [e.style['break-inside'\] = "avoid-column" should set the property value]
+    expected: FAIL
+
+  [e.style['break-inside'\] = "avoid-page" should set the property value]
+    expected: FAIL
+
+  [e.style['break-inside'\] = "avoid-region" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/orphans-valid.html.ini
@@ -0,0 +1,7 @@
+[orphans-valid.html]
+  [e.style['orphans'\] = "234" should set the property value]
+    expected: FAIL
+
+  [e.style['orphans'\] = "1" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-break/parsing/widows-valid.html.ini
@@ -0,0 +1,7 @@
+[widows-valid.html]
+  [e.style['widows'\] = "1" should set the property value]
+    expected: FAIL
+
+  [e.style['widows'\] = "234" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-contain/contain-layout-baseline-004.html.ini
@@ -0,0 +1,2 @@
+[contain-layout-baseline-004.html]
+  expected: FAIL

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-multicol/parsing/column-fill-computed.html.ini
@@ -0,0 +1,4 @@
+[column-fill-computed.html]
+  [Property column-fill value 'balance-all' computes to 'balance-all']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-multicol/parsing/column-fill-valid.html.ini
@@ -0,0 +1,4 @@
+[column-fill-valid.html]
+  [e.style['column-fill'\] = "balance-all" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-multicol/parsing/column-gap-computed.html.ini
@@ -0,0 +1,4 @@
+[column-gap-computed.html]
+  [Property column-gap value 'calc(50% + 60px)' computes to 'calc(50% + 60px)']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-multicol/parsing/column-rule-valid.html.ini
@@ -0,0 +1,10 @@
+[column-rule-valid.html]
+  [e.style['column-rule'\] = "dotted" should set the property value]
+    expected: FAIL
+
+  [e.style['column-rule'\] = "red" should set the property value]
+    expected: FAIL
+
+  [e.style['column-rule'\] = "10px" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-multicol/parsing/column-span-valid.html.ini
@@ -0,0 +1,7 @@
+[column-span-valid.html]
+  [e.style['column-span'\] = "none" should set the property value]
+    expected: FAIL
+
+  [e.style['column-span'\] = "all" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/bottom-computed.html.ini
@@ -0,0 +1,4 @@
+[bottom-computed.html]
+  [Property bottom value 'calc(50% + 60px)' computes to 'calc(50% + 60px)']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/inset-after-valid.html.ini
@@ -0,0 +1,13 @@
+[inset-after-valid.html]
+  [e.style['inset-after'\] = "auto" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-after'\] = "-20%" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-after'\] = "-10px" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-after'\] = "calc(2em + 3ex)" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/inset-before-valid.html.ini
@@ -0,0 +1,13 @@
+[inset-before-valid.html]
+  [e.style['inset-before'\] = "calc(2em + 3ex)" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-before'\] = "auto" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-before'\] = "-20%" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-before'\] = "-10px" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/inset-end-valid.html.ini
@@ -0,0 +1,13 @@
+[inset-end-valid.html]
+  [e.style['inset-end'\] = "auto" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-end'\] = "calc(2em + 3ex)" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-end'\] = "-10px" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-end'\] = "-20%" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/inset-start-valid.html.ini
@@ -0,0 +1,13 @@
+[inset-start-valid.html]
+  [e.style['inset-start'\] = "-20%" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-start'\] = "-10px" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-start'\] = "calc(2em + 3ex)" should set the property value]
+    expected: FAIL
+
+  [e.style['inset-start'\] = "auto" should set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/left-computed.html.ini
@@ -0,0 +1,4 @@
+[left-computed.html]
+  [Property left value 'calc(50% + 60px)' computes to 'calc(50% + 60px)']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/right-computed.html.ini
@@ -0,0 +1,4 @@
+[right-computed.html]
+  [Property right value 'calc(50% + 60px)' computes to 'calc(50% + 60px)']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/top-computed.html.ini
@@ -0,0 +1,4 @@
+[top-computed.html]
+  [Property top value 'calc(50% + 60px)' computes to 'calc(50% + 60px)']
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-position/parsing/z-index-invalid.html.ini
@@ -0,0 +1,4 @@
+[z-index-invalid.html]
+  [e.style['z-index'\] = "calc(0.5)" should not set the property value]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-shadow-parts/invalidation-change-part-name-idl-domtokenlist.html.ini
@@ -0,0 +1,4 @@
+[invalidation-change-part-name-idl-domtokenlist.html]
+  [Part in selected host changed color via part IDL DOMTokenList attribute.]
+    expected: FAIL
+

new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/css-shadow-parts/part-name-idl.html.ini
@@ -0,0 +1,13 @@
+[part-name-idl.html]
+  [Access to .part returns an empty DOMTokenList.]
+    expected: FAIL
+
+  [Changes in DOMTokenList are refected in attribute.]
+    expected: FAIL
+
+  [DOMTokenList created by access is persisted.]
+    expected: FAIL
+
+  [Multiple names give a DOMTokenList with multiple entries.]
+    expected: FAIL
+

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-margin-001.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-margin-001.html.ini
@@ -11,8 +11,24 @@
       if debug and not webrender and e10s and (os == "win") and (version == "10.0.15063") and (processor == "x86_64") and (bits == 64): PASS
       if not debug and not webrender and e10s and (os == "win") and (version == "10.0.15063") and (processor == "x86_64") and (bits == 64): PASS
       if not debug and not webrender and e10s and (os == "win") and (version == "6.1.7601") and (processor == "x86") and (bits == 32): PASS
       if debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): PASS
       if not debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): PASS
       if os == "android": PASS
       FAIL
 
+  [10vh - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [10vmin - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [10vw - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [10vmax - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-circle-005.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-circle-005.html.ini
@@ -50,8 +50,24 @@
     expected: FAIL
 
   [test unit: vmin - circle(50vmin) - inline]
     expected: FAIL
 
   [test unit: vmax - circle(50vmax) - inline]
     expected: FAIL
 
+  [test unit: vw - circle(50vw) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - circle(50vmax) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - circle(50vmin) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - circle(50vh) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-ellipse-004.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-ellipse-004.html.ini
@@ -1696,8 +1696,328 @@
     expected: FAIL
 
   [test unit (inline): ch - ellipse(at bottom 70% right 80ch)]
     expected: FAIL
 
   [test unit (inline): em - ellipse(at left 50% top 50em)]
     expected: FAIL
 
+  [test unit (computed): vw - ellipse(at top 50vw right 80%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 50vmax 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at center 60vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at top 50vh left 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 50% 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at left 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at left 50vw top 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at right 80vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 60vmax center)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at top 50vh right 80%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at left 50% top 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 50vw 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at right 80% top 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at top 50vmin left 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at top 50vmax right 80%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at left 50% top 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at left 50vh bottom 70%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 50% 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at left 50vmin bottom 70%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at right 80vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at right 80vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at top 50vmin left 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at center 60vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at left 50% top 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at right 80% top 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at right 80% top 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at left 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at bottom 70% left 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 50vh 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at right 80% top 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 50% 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 70vw bottom)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at left 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at left 50vh top 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 50vh top)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at top 50% left 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at left 50vmax top 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 50vw 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 50vmin 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 50vmin top)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 50vh 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at left 50vw top 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 50% 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 60vh center)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at left 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at top 50vw left 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at top 50vmax left 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at left 50vmin top 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 50vw top)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at top 50% left 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at left 50% top 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at center 60vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 50vmin 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at top 50vh left 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at right 80vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 70vmax bottom)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at top 50vmin right 80%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at left 50vw bottom 70%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at center 60vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at top 50vmax left 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 60vmin center)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at bottom 70% left 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 50vmax top)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at top 50% left 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at left 50vmax bottom 70%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at top 50% left 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at left 50vmax top 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at left 50vh top 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at 70vmin bottom)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at 70vh bottom)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at bottom 70% left 50vw)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 50vmax 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vh - ellipse(at bottom 70% left 50vh)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at top 50vw left 50%)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmin - ellipse(at left 50vmin top 50vmin)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vw - ellipse(at 60vw center)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit (computed): vmax - ellipse(at 50vmax)]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-ellipse-005.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-ellipse-005.html.ini
@@ -541,8 +541,121 @@
   [test unit: vmax - ellipse(25% 50vmax) - inline]
     expected: FAIL
 
   [test unit: vmin - ellipse(farthest-side 75vmin) - inline]
     expected: FAIL
 
   [test unit: vh - ellipse(closest-side 75vh) - inline]
     expected: FAIL
+
+  [test unit: vw - ellipse(25vw farthest-side) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(50vh 25%) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(25% 50vmax) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(50vmin 25%) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(closest-side 75vh) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(25% 50vmin) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(25vh farthest-side) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(closest-side 75vmin) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(25vmin farthest-side) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(25% 50vw) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(closest-side 75vmax) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(farthest-side 75vmin) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(25% 50vh) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(50vw 25%) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(closest-side 75vw) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(50vh 100vh) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(50vw 100vw) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(farthest-side 75vmax) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(100vh 100px) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(50vmin 100vmin) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(50vmax 25%) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(100vw 100px) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(100vmax 100px) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(25vmax farthest-side) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vh - ellipse(farthest-side 75vh) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vw - ellipse(farthest-side 75vw) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmin - ellipse(100vmin 100px) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+
+  [test unit: vmax - ellipse(50vmax 100vmax) - computed]
+    expected:
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
+

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-inset-003.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-inset-003.html.ini
@@ -336,326 +336,326 @@
       if not debug and not webrender and e10s and (os == "win") and (version == "6.1.7601") and (processor == "x86") and (bits == 32): PASS
       if debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): PASS
       if not debug and not webrender and e10s and (os == "mac") and (version == "OS X 10.10.5") and (processor == "x86_64") and (bits == 64): PASS
       if os == "android": PASS
       FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax 40vmax / 10vmax 20vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax / 10vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin 40vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin / 10vmin 20vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin 40vmin / 10vmin 20vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax 40vmax / 10vmax 20vmax 30vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw / 10vw 20vw 30vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin 40vmin / 10vmin 20vmin 30vmin 40vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax / 10vmax 20vmax 30vmax 40vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin / 10vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax / 10vmax 20vmax 30vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw / 10vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin / 10vmin 20vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw / 10vw 20vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax / 10vmax 20vmax 30vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh / 10vh 20vh 30vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw / 10vw 20vw 30vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh 40vh / 10vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh / 10vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh / 10vh 20vh 30vh 40vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh / 10vh 20vh 30vh 40vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax / 10vmax 20vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh / 10vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh 40vh / 10vh 20vh 30vh 40vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh / 10vh 20vh 30vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh / 10vh 20vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin / 10vmin 20vmin 30vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw / 10vw 20vw 30vw 40vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax / 10vmax 20vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax / 10vmax 20vmax 30vmax 40vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw / 10vw 20vw 30vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax 40vmax / 10vmax 20vmax 30vmax 40vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin / 10vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin / 10vmin 20vmin 30vmin 40vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax 40vmax / 10vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin / 10vmin 20vmin 30vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin 40vmin / 10vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw 40vw / 10vw 20vw 30vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin / 10vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin / 10vmin 20vmin 30vmin 40vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax / 10vmax 20vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax 40vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh / 10vh 20vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh / 10vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw 40vw / 10vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin / 10vmin 20vmin 30vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax / 10vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw / 10vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax / 10vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin / 10vmin 20vmin 30vmin 40vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax / 10vmax 20vmax 30vmax 40vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax 30vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw 40vw / 10vw 20vw 30vw 40vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin 40vmin / 10vmin 20vmin 30vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh 40vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh / 10vh 20vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh / 10vh 20vh 30vh 40vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw / 10vw 20vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw / 10vw 20vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw 40vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw / 10vw 20vw 30vw 40vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh 40vh / 10vh 20vh 30vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh 30vh 40vh / 10vh 20vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw 30vw 40vw / 10vw 20vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vh round 10vh 20vh / 10vh 20vh 30vh) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw / 10vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmax round 10vmax 20vmax / 10vmax 20vmax 30vmax) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vw round 10vw 20vw / 10vw 20vw 30vw 40vw) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [inset(10vmin round 10vmin 20vmin 30vmin / 10vmin 20vmin) - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 

--- a/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-polygon-004.html.ini
+++ b/testing/web-platform/meta/css/css-shapes/shape-outside/values/shape-outside-polygon-004.html.ini
@@ -59,70 +59,70 @@
   [Three vertices - cm cm, mm mm, pc pc - computed]
     expected: FAIL
 
   [Three vertices - pc pc, cm, cm, mm mm - computed]
     expected: FAIL
 
   [Two vertices - vw vw, vh vh - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Two vertices - vmin vmin, vmin vmin - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vw vw, vh vh, % % - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - % %, vw, vw, vh vh - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vw vw, vw vw, vw vw - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vmax vmax, vmin, vmin, vmin vmin - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vmin vmin, vmin vmin, vmin vmin - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vh vh, vh vh, vh vh - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vmin vmin, vmin vmin, vmax vmax - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Two vertices - vw vh, vh vw - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [One vertex - vw vh - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Three vertices - vmax vmax, vmax vmax, vmax vmax - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Two vertices - vh vh, vw vw - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [One vertex - vmin vmin - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [Two vertices - vw vw, vw vw - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL
 
   [One vertex - vw vw - computed]
     expected:
-      if os == "android": FAIL
+      if not debug and not webrender and not e10s and (os == "android") and (version == "Ubuntu 16.04") and (processor == "x86") and (bits == 32): FAIL