Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

39 files changed, 12362 insertions, 0 deletions

diff --git a/browser/base/content/test/webrtc/browser.ini b/browser/base/content/test/webrtc/browser.ini
new file mode 100644
index 0000000000..63ae7704c8
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser.ini
@@ -0,0 +1,118 @@
+[DEFAULT]
+support-files =
+  get_user_media.html
+  get_user_media2.html
+  get_user_media_in_frame.html
+  get_user_media_in_xorigin_frame.html
+  get_user_media_in_xorigin_frame_ancestor.html
+  head.js
+  peerconnection_connect.html
+  single_peerconnection.html
+
+prefs =
+  privacy.webrtc.allowSilencingNotifications=true
+  privacy.webrtc.legacyGlobalIndicator=false
+  privacy.webrtc.sharedTabWarning=false
+  privacy.webrtc.deviceGracePeriodTimeoutMs=0
+
+[browser_WebrtcGlobalInformation.js]
+[browser_device_controls_menus.js]
+skip-if =
+  debug # bug 1369731
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_devices_get_user_media.js]
+https_first_disabled = true
+skip-if =
+  os == "linux" && bits == 64 # linux: bug 976544, Bug 1616011
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[browser_devices_get_user_media_anim.js]
+https_first_disabled = true
+skip-if =
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[browser_devices_get_user_media_by_device_id.js]
+https_first_disabled = true
+[browser_devices_get_user_media_default_permissions.js]
+https_first_disabled = true
+[browser_devices_get_user_media_in_frame.js]
+https_first_disabled = true
+skip-if = debug # bug 1369731
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[browser_devices_get_user_media_in_xorigin_frame.js]
+https_first_disabled = true
+skip-if =
+  debug # bug 1369731
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[browser_devices_get_user_media_in_xorigin_frame_chain.js]
+https_first_disabled = true
+[browser_devices_get_user_media_multi_process.js]
+https_first_disabled = true
+skip-if =
+  (debug && os == "win") # bug 1393761
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_devices_get_user_media_paused.js]
+https_first_disabled = true
+skip-if =
+  (os == "win" && !debug) # Bug 1440900
+  (os =="linux" && !debug && bits == 64) # Bug 1440900
+  apple_silicon  # bug 1707735
+  apple_catalina # platform migration
+[browser_devices_get_user_media_queue_request.js]
+https_first_disabled = true
+skip-if =
+  os == "linux" # Bug 1775945
+  os == "win" && !debug # Bug 1775945
+[browser_devices_get_user_media_screen.js]
+https_first_disabled = true
+skip-if =
+  (os == 'linux') # Bug 1503991
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+  os == 'win' # high frequency intermittent, bug 1739107
+[browser_devices_get_user_media_screen_tab_close.js]
+skip-if =
+  apple_catalina  # platform migration
+  apple_silicon   # bug 1707735
+[browser_devices_get_user_media_tear_off_tab.js]
+https_first_disabled = true
+skip-if =
+  apple_catalina  # platform migration
+  apple_silicon   # bug 1707735
+  os == "linux" # Bug 1775945
+  os == "win" && !debug # Bug 1775945
+[browser_devices_get_user_media_unprompted_access.js]
+skip-if =
+  os == "linux" && bits == 64 && !debug # Bug 1712012
+https_first_disabled = true
+[browser_devices_get_user_media_unprompted_access_in_frame.js]
+https_first_disabled = true
+[browser_devices_get_user_media_unprompted_access_queue_request.js]
+https_first_disabled = true
+[browser_devices_get_user_media_unprompted_access_tear_off_tab.js]
+https_first_disabled = true
+skip-if = (os == "win" && bits == 64) # win8: bug 1334752
+[browser_devices_select_audio_output.js]
+[browser_global_mute_toggles.js]
+[browser_indicator_popuphiding.js]
+skip-if =
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_notification_silencing.js]
+skip-if =
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_stop_sharing_button.js]
+skip-if =
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_stop_streams_on_indicator_close.js]
+skip-if =
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[browser_tab_switch_warning.js]
+skip-if =
+  apple_catalina  # platform migration
+[browser_webrtc_hooks.js]
diff --git a/browser/base/content/test/webrtc/browser_WebrtcGlobalInformation.js b/browser/base/content/test/webrtc/browser_WebrtcGlobalInformation.js
new file mode 100644
index 0000000000..d66aa00461
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_WebrtcGlobalInformation.js
@@ -0,0 +1,484 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const ProcessTools = Cc["@mozilla.org/processtools-service;1"].getService(
+  Ci.nsIProcessToolsService
+);
+
+let getStatsReports = async (filter = "") => {
+  let { reports } = await new Promise(r =>
+    WebrtcGlobalInformation.getAllStats(r, filter)
+  );
+
+  ok(Array.isArray(reports), "|reports| is an array");
+
+  let sanityCheckReport = report => {
+    isnot(report.pcid, "", "pcid is non-empty");
+    if (filter.length) {
+      is(report.pcid, filter, "pcid matches filter");
+    }
+
+    // Check for duplicates
+    const checkForDuplicateId = statsArray => {
+      ok(Array.isArray(statsArray), "|statsArray| is an array");
+      const ids = new Set();
+      statsArray.forEach(stat => {
+        is(typeof stat.id, "string", "|stat.id| is a string");
+        ok(
+          !ids.has(stat.id),
+          `Id ${stat.id} should appear only once. Stat was ${JSON.stringify(
+            stat
+          )}`
+        );
+        ids.add(stat.id);
+      });
+    };
+
+    checkForDuplicateId(report.inboundRtpStreamStats);
+    checkForDuplicateId(report.outboundRtpStreamStats);
+    checkForDuplicateId(report.remoteInboundRtpStreamStats);
+    checkForDuplicateId(report.remoteOutboundRtpStreamStats);
+    checkForDuplicateId(report.rtpContributingSourceStats);
+    checkForDuplicateId(report.iceCandidatePairStats);
+    checkForDuplicateId(report.iceCandidateStats);
+    checkForDuplicateId(report.trickledIceCandidateStats);
+    checkForDuplicateId(report.dataChannelStats);
+    checkForDuplicateId(report.codecStats);
+  };
+
+  reports.forEach(sanityCheckReport);
+  return reports;
+};
+
+const getStatsHistoryPcIds = async () => {
+  return new Promise(r => WebrtcGlobalInformation.getStatsHistoryPcIds(r));
+};
+
+const getStatsHistorySince = async (pcid, after, sdpAfter) => {
+  return new Promise(r =>
+    WebrtcGlobalInformation.getStatsHistorySince(r, pcid, after, sdpAfter)
+  );
+};
+
+let getLogging = async () => {
+  let logs = await new Promise(r => WebrtcGlobalInformation.getLogging("", r));
+  ok(Array.isArray(logs), "|logs| is an array");
+  return logs;
+};
+
+let checkStatsReportCount = async (count, filter = "") => {
+  let reports = await getStatsReports(filter);
+  is(reports.length, count, `|reports| should have length ${count}`);
+  if (reports.length != count) {
+    info(`reports = ${JSON.stringify(reports)}`);
+  }
+  return reports;
+};
+
+let checkLoggingEmpty = async () => {
+  let logs = await getLogging();
+  is(logs.length, 0, "Logging is empty");
+  if (logs.length) {
+    info(`logs = ${JSON.stringify(logs)}`);
+  }
+  return logs;
+};
+
+let checkLoggingNonEmpty = async () => {
+  let logs = await getLogging();
+  isnot(logs.length, 0, "Logging is not empty");
+  return logs;
+};
+
+let clearAndCheck = async () => {
+  WebrtcGlobalInformation.clearAllStats();
+  WebrtcGlobalInformation.clearLogging();
+  await checkStatsReportCount(0);
+  await checkLoggingEmpty();
+};
+
+let openTabInNewProcess = async file => {
+  let rootDir = getRootDirectory(gTestPath);
+  rootDir = rootDir.replace(
+    "chrome://mochitests/content/",
+    "https://example.com/"
+  );
+  let absoluteURI = rootDir + file;
+
+  return BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: absoluteURI,
+    forceNewProcess: true,
+  });
+};
+
+let killTabProcess = async tab => {
+  await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    ChromeUtils.privateNoteIntentionalCrash();
+  });
+  ProcessTools.kill(tab.linkedBrowser.frameLoader.remoteTab.osPid);
+};
+
+add_task(async () => {
+  info("Test that clearAllStats is callable");
+  WebrtcGlobalInformation.clearAllStats();
+  ok(true, "clearAllStats returns");
+});
+
+add_task(async () => {
+  info("Test that clearLogging is callable");
+  WebrtcGlobalInformation.clearLogging();
+  ok(true, "clearLogging returns");
+});
+
+add_task(async () => {
+  info(
+    "Test that getAllStats is callable, and returns 0 results when no RTCPeerConnections have existed"
+  );
+  await checkStatsReportCount(0);
+});
+
+add_task(async () => {
+  info(
+    "Test that getLogging is callable, and returns 0 results when no RTCPeerConnections have existed"
+  );
+  await checkLoggingEmpty();
+});
+
+add_task(async () => {
+  info("Test that we can get stats/logging for a PC on the parent process");
+  await clearAndCheck();
+  let pc = new RTCPeerConnection();
+  await pc.setLocalDescription(
+    await pc.createOffer({ offerToReceiveAudio: true })
+  );
+  // Let ICE stack go quiescent
+  await new Promise(r => {
+    pc.onicegatheringstatechange = () => {
+      if (pc.iceGatheringState == "complete") {
+        r();
+      }
+    };
+  });
+  await checkStatsReportCount(1);
+  await checkLoggingNonEmpty();
+  pc.close();
+  pc = null;
+  // Closing a PC should not do anything to the ICE logging
+  await checkLoggingNonEmpty();
+  // There's just no way to get a signal that the ICE stack has stopped logging
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 2000));
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info("Test that we can get stats/logging for a PC on a content process");
+  await clearAndCheck();
+  let tab = await openTabInNewProcess("single_peerconnection.html");
+  await checkStatsReportCount(1);
+  await checkLoggingNonEmpty();
+  await killTabProcess(tab);
+  BrowserTestUtils.removeTab(tab);
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info(
+    "Test that we can get stats/logging for two connected PCs on a content process"
+  );
+  await clearAndCheck();
+  let tab = await openTabInNewProcess("peerconnection_connect.html");
+  await checkStatsReportCount(2);
+  await checkLoggingNonEmpty();
+  await killTabProcess(tab);
+  BrowserTestUtils.removeTab(tab);
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info("Test filtering for stats reports (parent process)");
+  await clearAndCheck();
+  let pc1 = new RTCPeerConnection();
+  let pc2 = new RTCPeerConnection();
+  let allReports = await checkStatsReportCount(2);
+  await checkStatsReportCount(1, allReports[0].pcid);
+  pc1.close();
+  pc2.close();
+  pc1 = null;
+  pc2 = null;
+  await checkStatsReportCount(1, allReports[0].pcid);
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info("Test filtering for stats reports (content process)");
+  await clearAndCheck();
+  let tab1 = await openTabInNewProcess("single_peerconnection.html");
+  let tab2 = await openTabInNewProcess("single_peerconnection.html");
+  let allReports = await checkStatsReportCount(2);
+  await checkStatsReportCount(1, allReports[0].pcid);
+  await killTabProcess(tab1);
+  BrowserTestUtils.removeTab(tab1);
+  await killTabProcess(tab2);
+  BrowserTestUtils.removeTab(tab2);
+  await checkStatsReportCount(1, allReports[0].pcid);
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info("Test that stats/logging persists when PC is closed (parent process)");
+  await clearAndCheck();
+  let pc = new RTCPeerConnection();
+  // This stuff will generate logging
+  await pc.setLocalDescription(
+    await pc.createOffer({ offerToReceiveAudio: true })
+  );
+  // Once gathering is done, the ICE stack should go quiescent
+  await new Promise(r => {
+    pc.onicegatheringstatechange = () => {
+      if (pc.iceGatheringState == "complete") {
+        r();
+      }
+    };
+  });
+  let reports = await checkStatsReportCount(1);
+  isnot(
+    window.browsingContext.browserId,
+    undefined,
+    "browserId is defined for parent process"
+  );
+  is(
+    reports[0].browserId,
+    window.browsingContext.browserId,
+    "browserId for stats report matches parent process"
+  );
+  await checkLoggingNonEmpty();
+  pc.close();
+  pc = null;
+  await checkStatsReportCount(1);
+  await checkLoggingNonEmpty();
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  info("Test that stats/logging persists when PC is closed (content process)");
+  await clearAndCheck();
+  let tab = await openTabInNewProcess("single_peerconnection.html");
+  let { browserId } = tab.linkedBrowser;
+  let reports = await checkStatsReportCount(1);
+  is(reports[0].browserId, browserId, "browserId for stats report matches tab");
+  isnot(
+    browserId,
+    window.browsingContext.browserId,
+    "tab browser id is not the same as parent process browser id"
+  );
+  await checkLoggingNonEmpty();
+  await killTabProcess(tab);
+  BrowserTestUtils.removeTab(tab);
+  await checkStatsReportCount(1);
+  await checkLoggingNonEmpty();
+  await clearAndCheck();
+});
+
+const set_int_pref_returning_unsetter = (pref, num) => {
+  const value = Services.prefs.getIntPref(pref);
+  Services.prefs.setIntPref(pref, num);
+  return () => Services.prefs.setIntPref(pref, value);
+};
+
+const stats_history_is_enabled = () => {
+  return Services.prefs.getBoolPref("media.aboutwebrtc.hist.enabled");
+};
+
+const set_max_histories_to_retain = num =>
+  set_int_pref_returning_unsetter(
+    "media.aboutwebrtc.hist.closed_stats_to_retain",
+    num
+  );
+
+const set_history_storage_window_s = num =>
+  set_int_pref_returning_unsetter(
+    "media.aboutwebrtc.hist.storage_window_s",
+    num
+  );
+
+add_task(async () => {
+  if (!stats_history_is_enabled()) {
+    return;
+  }
+  info(
+    "Test that stats history is available after close until clearLongTermStats is called"
+  );
+  await clearAndCheck();
+  const pc = new RTCPeerConnection();
+
+  const ids = await getStatsHistoryPcIds();
+  is(ids.length, 1, "There is a single PeerConnection Id for stats history.");
+
+  let firstLen = 0;
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 2000));
+  {
+    const history = await getStatsHistorySince(ids[0]);
+    firstLen = history.reports.length;
+    ok(
+      history.reports.length,
+      "There is at least a single PeerConnection stats history before close."
+    );
+  }
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 2000));
+  {
+    const history = await getStatsHistorySince(ids[0]);
+    const secondLen = history.reports.length;
+    ok(
+      secondLen > firstLen,
+      "After waiting there are more history entries available."
+    );
+  }
+  pc.close();
+  // After close for final stats and pc teardown to settle
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 2000));
+  {
+    const history = await getStatsHistorySince(ids[0]);
+    ok(
+      history.reports.length,
+      "There is at least a single PeerConnection stats history after close."
+    );
+  }
+  await clearAndCheck();
+  {
+    const history = await getStatsHistorySince(ids[0]);
+    is(
+      history.reports.length,
+      0,
+      "After PC.close and clearing the stats there are no history reports"
+    );
+  }
+  {
+    const ids1 = await getStatsHistoryPcIds();
+    is(
+      ids1.length,
+      0,
+      "After PC.close and clearing the stats there are no history pcids"
+    );
+  }
+  {
+    const pc2 = new RTCPeerConnection();
+    const pc3 = new RTCPeerConnection();
+    let idsN = await getStatsHistoryPcIds();
+    is(
+      idsN.length,
+      2,
+      "There are two pcIds after creating two PeerConnections"
+    );
+    pc2.close();
+    // After close for final stats and pc teardown to settle
+    // I "don't love" this but we don't have a anything we can await on ... yet.
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(r => setTimeout(r, 2000));
+    await WebrtcGlobalInformation.clearAllStats();
+    idsN = await getStatsHistoryPcIds();
+    is(
+      idsN.length,
+      1,
+      "There is one pcIds after closing one of two PeerConnections and clearing stats"
+    );
+    pc3.close();
+    // After close for final stats and pc teardown to settle
+    // I "don't love" this but we don't have a anything we can await on ... yet.
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(r => setTimeout(r, 2000));
+  }
+});
+
+add_task(async () => {
+  if (!stats_history_is_enabled()) {
+    return;
+  }
+  const restoreHistRetainPref = set_max_histories_to_retain(7);
+  info("Test that the proper number of pcIds are available");
+  await clearAndCheck();
+  const pc01 = new RTCPeerConnection();
+  const pc02 = new RTCPeerConnection();
+  const pc03 = new RTCPeerConnection();
+  const pc04 = new RTCPeerConnection();
+  const pc05 = new RTCPeerConnection();
+  const pc06 = new RTCPeerConnection();
+  const pc07 = new RTCPeerConnection();
+  const pc08 = new RTCPeerConnection();
+  const pc09 = new RTCPeerConnection();
+  const pc10 = new RTCPeerConnection();
+  const pc11 = new RTCPeerConnection();
+  const pc12 = new RTCPeerConnection();
+  const pc13 = new RTCPeerConnection();
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 2000));
+  {
+    const ids = await getStatsHistoryPcIds();
+    is(ids.length, 13, "There is are 13 PeerConnection Ids for stats history.");
+  }
+  pc01.close();
+  pc02.close();
+  pc03.close();
+  pc04.close();
+  pc05.close();
+  pc06.close();
+  pc07.close();
+  pc08.close();
+  pc09.close();
+  pc10.close();
+  pc11.close();
+  pc12.close();
+  pc13.close();
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, 5000));
+  {
+    const ids = await getStatsHistoryPcIds();
+    is(
+      ids.length,
+      7,
+      "After closing 13 PCs there are no more than the max closed (7) PeerConnection Ids for stats history."
+    );
+  }
+  restoreHistRetainPref();
+  await clearAndCheck();
+});
+
+add_task(async () => {
+  if (!stats_history_is_enabled()) {
+    return;
+  }
+  // If you change this, please check if the setTimeout should be updated.
+  // NOTE: the unit here is _integer_ seconds.
+  const STORAGE_WINDOW_S = 1;
+  const restoreStorageWindowPref =
+    set_history_storage_window_s(STORAGE_WINDOW_S);
+  info("Test that history items are being aged out");
+  await clearAndCheck();
+  const pc = new RTCPeerConnection();
+  // I "don't love" this but we don't have a anything we can await on ... yet.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(r => setTimeout(r, STORAGE_WINDOW_S * 2 * 1000));
+  const ids = await getStatsHistoryPcIds();
+  const { reports } = await getStatsHistorySince(ids[0]);
+  const first = reports[0];
+  const last = reports.at(-1);
+  ok(
+    last.timestamp - first.timestamp <= STORAGE_WINDOW_S * 1000,
+    "History reports should be aging out according to the storage window pref"
+  );
+  pc.close();
+  restoreStorageWindowPref();
+  await clearAndCheck();
+});
diff --git a/browser/base/content/test/webrtc/browser_device_controls_menus.js b/browser/base/content/test/webrtc/browser_device_controls_menus.js
new file mode 100644
index 0000000000..3d6602bc5e
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_device_controls_menus.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+/**
+ * Regression test for bug 1669801, where sharing a window would
+ * result in a device control menu that showed the wrong count.
+ */
+add_task(async function test_bug_1669801() {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(
+      browser,
+      false /* camera */,
+      false /* microphone */,
+      SHARE_WINDOW
+    );
+
+    let indicator = await indicatorPromise;
+    let doc = indicator.document;
+
+    let menupopup = doc.querySelector("menupopup[type='Screen']");
+    let popupShownPromise = BrowserTestUtils.waitForEvent(
+      menupopup,
+      "popupshown"
+    );
+    menupopup.openPopup(doc.body, {});
+    await popupShownPromise;
+
+    let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+      menupopup,
+      "popuphidden"
+    );
+    menupopup.hidePopup();
+    await popupHiddenPromise;
+    await closeStream();
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media.js b/browser/base/content/test/webrtc/browser_devices_get_user_media.js
new file mode 100644
index 0000000000..3ef88b976d
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media.js
@@ -0,0 +1,949 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+requestLongerTimeout(2);
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+video",
+    run: async function checkAudioVideo() {
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareDevices-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      promise = promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      await promise;
+
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio only",
+    run: async function checkAudioOnly() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareMicrophone-notification-icon",
+        "anchored to mic icon"
+      );
+      checkDeviceSelectors(["microphone"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      promise = promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      await promise;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia video only",
+    run: async function checkVideoOnly() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareDevices-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: 'getUserMedia audio+video, user clicks "Don\'t Share"',
+    run: async function checkDontShare() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      let observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkNotSharing();
+
+      // Verify that we set 'Temporarily blocked' permissions.
+      let browser = gBrowser.selectedBrowser;
+      let blockedPerms = document.getElementById(
+        "blocked-permissions-container"
+      );
+
+      let { state, scope } = SitePermissions.getForPrincipal(
+        null,
+        "camera",
+        browser
+      );
+      Assert.equal(state, SitePermissions.BLOCK);
+      Assert.equal(scope, SitePermissions.SCOPE_TEMPORARY);
+      ok(
+        blockedPerms.querySelector(
+          ".blocked-permission-icon.camera-icon[showing=true]"
+        ),
+        "the blocked camera icon is shown"
+      );
+
+      ({ state, scope } = SitePermissions.getForPrincipal(
+        null,
+        "microphone",
+        browser
+      ));
+      Assert.equal(state, SitePermissions.BLOCK);
+      Assert.equal(scope, SitePermissions.SCOPE_TEMPORARY);
+      ok(
+        blockedPerms.querySelector(
+          ".blocked-permission-icon.microphone-icon[showing=true]"
+        ),
+        "the blocked microphone icon is shown"
+      );
+
+      info("requesting devices again to check temporarily blocked permissions");
+      promise = promiseMessage(permissionError);
+      observerPromise1 = expectObserverCalled("getUserMedia:request");
+      observerPromise2 = expectObserverCalled("getUserMedia:response:deny");
+      let observerPromise3 = expectObserverCalled("recording-window-ended");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise1;
+      await observerPromise2;
+      await observerPromise3;
+      await checkNotSharing();
+
+      SitePermissions.removeFromPrincipal(
+        browser.contentPrincipal,
+        "camera",
+        browser
+      );
+      SitePermissions.removeFromPrincipal(
+        browser.contentPrincipal,
+        "microphone",
+        browser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: stop sharing",
+    run: async function checkStopSharing() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      await stopSharing();
+
+      // the stream is already closed, but this will do some cleanup anyway
+      await closeStream(true);
+
+      // After stop sharing, gUM(audio+camera) causes a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      await checkNotSharing();
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: reloading the page removes all gUM UI",
+    run: async function checkReloading() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      await reloadAndAssertClosedStreams();
+
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      // After the reload, gUM(audio+camera) causes a prompt.
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      await checkNotSharing();
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia prompt: Always/Never Share",
+    run: async function checkRememberCheckbox() {
+      let elt = id => document.getElementById(id);
+
+      async function checkPerm(
+        aRequestAudio,
+        aRequestVideo,
+        aExpectedAudioPerm,
+        aExpectedVideoPerm,
+        aNever
+      ) {
+        let observerPromise = expectObserverCalled("getUserMedia:request");
+        let promise = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(aRequestAudio, aRequestVideo);
+        await promise;
+        await observerPromise;
+
+        is(
+          elt("webRTC-selectMicrophone").hidden,
+          !aRequestAudio,
+          "microphone selector expected to be " +
+            (aRequestAudio ? "visible" : "hidden")
+        );
+
+        is(
+          elt("webRTC-selectCamera").hidden,
+          !aRequestVideo,
+          "camera selector expected to be " +
+            (aRequestVideo ? "visible" : "hidden")
+        );
+
+        let expected = {};
+        let observerPromises = [];
+        let expectedMessage = aNever ? permissionError : "ok";
+        if (expectedMessage == "ok") {
+          observerPromises.push(
+            expectObserverCalled("getUserMedia:response:allow")
+          );
+          observerPromises.push(
+            expectObserverCalled("recording-device-events")
+          );
+          if (aRequestVideo) {
+            expected.video = true;
+          }
+          if (aRequestAudio) {
+            expected.audio = true;
+          }
+        } else {
+          observerPromises.push(
+            expectObserverCalled("getUserMedia:response:deny")
+          );
+          observerPromises.push(expectObserverCalled("recording-window-ended"));
+        }
+        await promiseMessage(expectedMessage, () => {
+          activateSecondaryAction(aNever ? kActionNever : kActionAlways);
+        });
+        await Promise.all(observerPromises);
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          expected,
+          "expected " + Object.keys(expected).join(" and ") + " to be shared"
+        );
+
+        function checkDevicePermissions(aDevice, aExpected) {
+          let uri = gBrowser.selectedBrowser.documentURI;
+          let devicePerms = PermissionTestUtils.testExactPermission(
+            uri,
+            aDevice
+          );
+          if (aExpected === undefined) {
+            is(
+              devicePerms,
+              Services.perms.UNKNOWN_ACTION,
+              "no " + aDevice + " persistent permissions"
+            );
+          } else {
+            is(
+              devicePerms,
+              aExpected
+                ? Services.perms.ALLOW_ACTION
+                : Services.perms.DENY_ACTION,
+              aDevice + " persistently " + (aExpected ? "allowed" : "denied")
+            );
+          }
+          PermissionTestUtils.remove(uri, aDevice);
+        }
+        checkDevicePermissions("microphone", aExpectedAudioPerm);
+        checkDevicePermissions("camera", aExpectedVideoPerm);
+
+        if (expectedMessage == "ok") {
+          await closeStream();
+        }
+      }
+
+      // 3 cases where the user accepts the device prompt.
+      info("audio+video, user grants, expect both Services.perms set to allow");
+      await checkPerm(true, true, true, true);
+      info(
+        "audio only, user grants, check audio perm set to allow, video perm not set"
+      );
+      await checkPerm(true, false, true, undefined);
+      info(
+        "video only, user grants, check video perm set to allow, audio perm not set"
+      );
+      await checkPerm(false, true, undefined, true);
+
+      // 3 cases where the user rejects the device request by using 'Never Share'.
+      info(
+        "audio only, user denies, expect audio perm set to deny, video not set"
+      );
+      await checkPerm(true, false, false, undefined, true);
+      info(
+        "video only, user denies, expect video perm set to deny, audio perm not set"
+      );
+      await checkPerm(false, true, undefined, false, true);
+      info("audio+video, user denies, expect both Services.perms set to deny");
+      await checkPerm(true, true, false, false, true);
+    },
+  },
+
+  {
+    desc: "getUserMedia without prompt: use persistent permissions",
+    run: async function checkUsePersistentPermissions() {
+      async function usePerm(
+        aAllowAudio,
+        aAllowVideo,
+        aRequestAudio,
+        aRequestVideo,
+        aExpectStream
+      ) {
+        let uri = gBrowser.selectedBrowser.documentURI;
+
+        if (aAllowAudio !== undefined) {
+          PermissionTestUtils.add(
+            uri,
+            "microphone",
+            aAllowAudio
+              ? Services.perms.ALLOW_ACTION
+              : Services.perms.DENY_ACTION
+          );
+        }
+        if (aAllowVideo !== undefined) {
+          PermissionTestUtils.add(
+            uri,
+            "camera",
+            aAllowVideo
+              ? Services.perms.ALLOW_ACTION
+              : Services.perms.DENY_ACTION
+          );
+        }
+
+        if (aExpectStream === undefined) {
+          // Check that we get a prompt.
+          let observerPromise = expectObserverCalled("getUserMedia:request");
+          let promise = promisePopupNotificationShown("webRTC-shareDevices");
+          await promiseRequestDevice(aRequestAudio, aRequestVideo);
+          await promise;
+          await observerPromise;
+
+          // Deny the request to cleanup...
+          let observerPromise1 = expectObserverCalled(
+            "getUserMedia:response:deny"
+          );
+          let observerPromise2 = expectObserverCalled("recording-window-ended");
+          await promiseMessage(permissionError, () => {
+            activateSecondaryAction(kActionDeny);
+          });
+          await observerPromise1;
+          await observerPromise2;
+
+          let browser = gBrowser.selectedBrowser;
+          SitePermissions.removeFromPrincipal(null, "camera", browser);
+          SitePermissions.removeFromPrincipal(null, "microphone", browser);
+        } else {
+          let expectedMessage = aExpectStream ? "ok" : permissionError;
+
+          let observerPromises = [expectObserverCalled("getUserMedia:request")];
+          if (expectedMessage == "ok") {
+            observerPromises.push(
+              expectObserverCalled("getUserMedia:response:allow"),
+              expectObserverCalled("recording-device-events")
+            );
+          } else {
+            observerPromises.push(
+              expectObserverCalled("getUserMedia:response:deny"),
+              expectObserverCalled("recording-window-ended")
+            );
+          }
+
+          let promise = promiseMessage(expectedMessage);
+          await promiseRequestDevice(aRequestAudio, aRequestVideo);
+          await promise;
+          await Promise.all(observerPromises);
+
+          if (expectedMessage == "ok") {
+            await promiseNoPopupNotification("webRTC-shareDevices");
+
+            // Check what's actually shared.
+            let expected = {};
+            if (aAllowVideo && aRequestVideo) {
+              expected.video = true;
+            }
+            if (aAllowAudio && aRequestAudio) {
+              expected.audio = true;
+            }
+            Assert.deepEqual(
+              await getMediaCaptureState(),
+              expected,
+              "expected " +
+                Object.keys(expected).join(" and ") +
+                " to be shared"
+            );
+
+            await closeStream();
+          }
+        }
+
+        PermissionTestUtils.remove(uri, "camera");
+        PermissionTestUtils.remove(uri, "microphone");
+      }
+
+      // Set both permissions identically
+      info("allow audio+video, request audio+video, expect ok (audio+video)");
+      await usePerm(true, true, true, true, true);
+      info("deny audio+video, request audio+video, expect denied");
+      await usePerm(false, false, true, true, false);
+
+      // Allow audio, deny video.
+      info("allow audio, deny video, request audio+video, expect denied");
+      await usePerm(true, false, true, true, false);
+      info("allow audio, deny video, request audio, expect ok (audio)");
+      await usePerm(true, false, true, false, true);
+      info("allow audio, deny video, request video, expect denied");
+      await usePerm(true, false, false, true, false);
+
+      // Deny audio, allow video.
+      info("deny audio, allow video, request audio+video, expect denied");
+      await usePerm(false, true, true, true, false);
+      info("deny audio, allow video, request audio, expect denied");
+      await usePerm(false, true, true, false, false);
+      info("deny audio, allow video, request video, expect ok (video)");
+      await usePerm(false, true, false, true, true);
+
+      // Allow audio, video not set.
+      info("allow audio, request audio+video, expect prompt");
+      await usePerm(true, undefined, true, true, undefined);
+      info("allow audio, request audio, expect ok (audio)");
+      await usePerm(true, undefined, true, false, true);
+      info("allow audio, request video, expect prompt");
+      await usePerm(true, undefined, false, true, undefined);
+
+      // Deny audio, video not set.
+      info("deny audio, request audio+video, expect denied");
+      await usePerm(false, undefined, true, true, false);
+      info("deny audio, request audio, expect denied");
+      await usePerm(false, undefined, true, false, false);
+      info("deny audio, request video, expect prompt");
+      await usePerm(false, undefined, false, true, undefined);
+
+      // Allow video, audio not set.
+      info("allow video, request audio+video, expect prompt");
+      await usePerm(undefined, true, true, true, undefined);
+      info("allow video, request audio, expect prompt");
+      await usePerm(undefined, true, true, false, undefined);
+      info("allow video, request video, expect ok (video)");
+      await usePerm(undefined, true, false, true, true);
+
+      // Deny video, audio not set.
+      info("deny video, request audio+video, expect denied");
+      await usePerm(undefined, false, true, true, false);
+      info("deny video, request audio, expect prompt");
+      await usePerm(undefined, false, true, false, undefined);
+      info("deny video, request video, expect denied");
+      await usePerm(undefined, false, false, true, false);
+    },
+  },
+
+  {
+    desc: "Stop Sharing removes permissions",
+    run: async function checkStopSharingRemovesPermissions() {
+      async function stopAndCheckPerm(
+        aRequestAudio,
+        aRequestVideo,
+        aStopAudio = aRequestAudio,
+        aStopVideo = aRequestVideo
+      ) {
+        let uri = gBrowser.selectedBrowser.documentURI;
+
+        // Initially set both permissions to 'allow'.
+        PermissionTestUtils.add(uri, "microphone", Services.perms.ALLOW_ACTION);
+        PermissionTestUtils.add(uri, "camera", Services.perms.ALLOW_ACTION);
+        // Also set device-specific temporary allows.
+        SitePermissions.setForPrincipal(
+          gBrowser.contentPrincipal,
+          "microphone^myDevice",
+          SitePermissions.ALLOW,
+          SitePermissions.SCOPE_TEMPORARY,
+          gBrowser.selectedBrowser,
+          10000000
+        );
+        SitePermissions.setForPrincipal(
+          gBrowser.contentPrincipal,
+          "camera^myDevice2",
+          SitePermissions.ALLOW,
+          SitePermissions.SCOPE_TEMPORARY,
+          gBrowser.selectedBrowser,
+          10000000
+        );
+
+        if (aRequestAudio || aRequestVideo) {
+          let indicator = promiseIndicatorWindow();
+          let observerPromise1 = expectObserverCalled("getUserMedia:request");
+          let observerPromise2 = expectObserverCalled(
+            "getUserMedia:response:allow"
+          );
+          let observerPromise3 = expectObserverCalled(
+            "recording-device-events"
+          );
+          // Start sharing what's been requested.
+          let promise = promiseMessage("ok");
+          await promiseRequestDevice(aRequestAudio, aRequestVideo);
+          await promise;
+          await observerPromise1;
+          await observerPromise2;
+          await observerPromise3;
+
+          await indicator;
+          await checkSharingUI(
+            { video: aRequestVideo, audio: aRequestAudio },
+            undefined,
+            undefined,
+            {
+              video: { scope: SitePermissions.SCOPE_PERSISTENT },
+              audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+            }
+          );
+          await stopSharing(aStopVideo ? "camera" : "microphone");
+        } else {
+          await revokePermission(aStopVideo ? "camera" : "microphone");
+        }
+
+        // Check that permissions have been removed as expected.
+        let audioPerm = SitePermissions.getForPrincipal(
+          gBrowser.contentPrincipal,
+          "microphone",
+          gBrowser.selectedBrowser
+        );
+        let audioPermDevice = SitePermissions.getForPrincipal(
+          gBrowser.contentPrincipal,
+          "microphone^myDevice",
+          gBrowser.selectedBrowser
+        );
+
+        if (
+          aRequestAudio ||
+          aRequestVideo ||
+          aStopAudio ||
+          (aStopVideo && aRequestAudio)
+        ) {
+          Assert.deepEqual(
+            audioPerm,
+            {
+              state: SitePermissions.UNKNOWN,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "microphone permissions removed"
+          );
+          Assert.deepEqual(
+            audioPermDevice,
+            {
+              state: SitePermissions.UNKNOWN,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "microphone device-specific permissions removed"
+          );
+        } else {
+          Assert.deepEqual(
+            audioPerm,
+            {
+              state: SitePermissions.ALLOW,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "microphone permissions untouched"
+          );
+          Assert.deepEqual(
+            audioPermDevice,
+            {
+              state: SitePermissions.ALLOW,
+              scope: SitePermissions.SCOPE_TEMPORARY,
+            },
+            "microphone device-specific permissions untouched"
+          );
+        }
+
+        let videoPerm = SitePermissions.getForPrincipal(
+          gBrowser.contentPrincipal,
+          "camera",
+          gBrowser.selectedBrowser
+        );
+        let videoPermDevice = SitePermissions.getForPrincipal(
+          gBrowser.contentPrincipal,
+          "camera^myDevice2",
+          gBrowser.selectedBrowser
+        );
+        if (
+          aRequestAudio ||
+          aRequestVideo ||
+          aStopVideo ||
+          (aStopAudio && aRequestVideo)
+        ) {
+          Assert.deepEqual(
+            videoPerm,
+            {
+              state: SitePermissions.UNKNOWN,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "camera permissions removed"
+          );
+          Assert.deepEqual(
+            videoPermDevice,
+            {
+              state: SitePermissions.UNKNOWN,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "camera device-specific permissions removed"
+          );
+        } else {
+          Assert.deepEqual(
+            videoPerm,
+            {
+              state: SitePermissions.ALLOW,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            "camera permissions untouched"
+          );
+          Assert.deepEqual(
+            videoPermDevice,
+            {
+              state: SitePermissions.ALLOW,
+              scope: SitePermissions.SCOPE_TEMPORARY,
+            },
+            "camera device-specific permissions untouched"
+          );
+        }
+        await checkNotSharing();
+
+        // Cleanup.
+        await closeStream(true);
+
+        SitePermissions.removeFromPrincipal(
+          gBrowser.contentPrincipal,
+          "camera",
+          gBrowser.selectedBrowser
+        );
+        SitePermissions.removeFromPrincipal(
+          gBrowser.contentPrincipal,
+          "microphone",
+          gBrowser.selectedBrowser
+        );
+      }
+
+      info("request audio+video, stop sharing video resets both");
+      await stopAndCheckPerm(true, true);
+      info("request audio only, stop sharing audio resets both");
+      await stopAndCheckPerm(true, false);
+      info("request video only, stop sharing video resets both");
+      await stopAndCheckPerm(false, true);
+      info("request audio only, stop sharing video resets both");
+      await stopAndCheckPerm(true, false, false, true);
+      info("request video only, stop sharing audio resets both");
+      await stopAndCheckPerm(false, true, true, false);
+      info("request neither, stop audio affects audio only");
+      await stopAndCheckPerm(false, false, true, false);
+      info("request neither, stop video affects video only");
+      await stopAndCheckPerm(false, false, false, true);
+    },
+  },
+
+  {
+    desc: "test showPermissionPanel",
+    run: async function checkShowPermissionPanel() {
+      if (!USING_LEGACY_INDICATOR) {
+        // The indicator only links to the permission panel for the
+        // legacy indicator.
+        return;
+      }
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true });
+
+      ok(permissionPopupHidden(), "permission panel should be hidden");
+      if (IS_MAC) {
+        let activeStreams = webrtcUI.getActiveStreams(true, false, false);
+        webrtcUI.showSharingDoorhanger(activeStreams[0]);
+      } else {
+        let win = Services.wm.getMostRecentWindow(
+          "Browser:WebRTCGlobalIndicator"
+        );
+
+        let elt = win.document.getElementById("audioVideoButton");
+        EventUtils.synthesizeMouseAtCenter(elt, {}, win);
+      }
+
+      await TestUtils.waitForCondition(
+        () => !permissionPopupHidden(),
+        "wait for permission panel to open"
+      );
+      ok(!permissionPopupHidden(), "permission panel should be open");
+
+      gPermissionPanel._permissionPopup.hidePopup();
+
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "'Always Allow' disabled on http pages",
+    run: async function checkNoAlwaysOnHttp() {
+      // Load an http page instead of the https version.
+      await SpecialPowers.pushPrefEnv({
+        set: [
+          ["media.devices.insecure.enabled", true],
+          ["media.getusermedia.insecure.enabled", true],
+          // explicitly testing an http page, setting
+          // https-first to false.
+          ["dom.security.https_first", false],
+        ],
+      });
+
+      // Disable while loading a new page
+      await disableObserverVerification();
+
+      let browser = gBrowser.selectedBrowser;
+      BrowserTestUtils.loadURIString(
+        browser,
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        browser.documentURI.spec.replace("https://", "http://")
+      );
+      await BrowserTestUtils.browserLoaded(browser);
+
+      await enableObserverVerification();
+
+      // Initially set both permissions to 'allow'.
+      let uri = browser.documentURI;
+      PermissionTestUtils.add(uri, "microphone", Services.perms.ALLOW_ACTION);
+      PermissionTestUtils.add(uri, "camera", Services.perms.ALLOW_ACTION);
+
+      // Request devices and expect a prompt despite the saved 'Allow' permission,
+      // because the connection isn't secure.
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+
+      // Ensure that checking the 'Remember this decision' checkbox disables
+      // 'Allow'.
+      let notification = PopupNotifications.panel.firstElementChild;
+      let checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.checked, "checkbox is not checked");
+      checkbox.click();
+      ok(checkbox.checked, "checkbox now checked");
+      ok(notification.button.disabled, "Allow button is disabled");
+      ok(
+        !notification.hasAttribute("warninghidden"),
+        "warning message is shown"
+      );
+
+      // Cleanup.
+      await closeStream(true);
+      PermissionTestUtils.remove(uri, "camera");
+      PermissionTestUtils.remove(uri, "microphone");
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_anim.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_anim.js
new file mode 100644
index 0000000000..dd20a672c3
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_anim.js
@@ -0,0 +1,106 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var gTests = [
+  {
+    desc: "device sharing animation on background tabs",
+    run: async function checkAudioVideo() {
+      async function getStreamAndCheckBackgroundAnim(aAudio, aVideo, aSharing) {
+        // Get a stream
+        let observerPromise = expectObserverCalled("getUserMedia:request");
+        let popupPromise = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(aAudio, aVideo);
+        await popupPromise;
+        await observerPromise;
+
+        let observerPromise1 = expectObserverCalled(
+          "getUserMedia:response:allow"
+        );
+        let observerPromise2 = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await observerPromise1;
+        await observerPromise2;
+        let expected = {};
+        if (aVideo) {
+          expected.video = true;
+        }
+        if (aAudio) {
+          expected.audio = true;
+        }
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          expected,
+          "expected " + Object.keys(expected).join(" and ") + " to be shared"
+        );
+
+        // Check the attribute on the tab, and check there's no visible
+        // sharing icon on the tab
+        let tab = gBrowser.selectedTab;
+        is(
+          tab.getAttribute("sharing"),
+          aSharing,
+          "the tab has the attribute to show the " + aSharing + " icon"
+        );
+        let icon = tab.sharingIcon;
+        is(
+          window.getComputedStyle(icon).display,
+          "none",
+          "the animated sharing icon of the tab is hidden"
+        );
+
+        // After selecting a new tab, check the attribute is still there,
+        // and the icon is now visible.
+        await BrowserTestUtils.switchTab(
+          gBrowser,
+          BrowserTestUtils.addTab(gBrowser)
+        );
+        is(
+          gBrowser.selectedTab.getAttribute("sharing"),
+          "",
+          "the new tab doesn't have the 'sharing' attribute"
+        );
+        is(
+          tab.getAttribute("sharing"),
+          aSharing,
+          "the tab still has the 'sharing' attribute"
+        );
+        isnot(
+          window.getComputedStyle(icon).display,
+          "none",
+          "the animated sharing icon of the tab is now visible"
+        );
+
+        // Ensure the icon disappears when selecting the tab.
+        BrowserTestUtils.removeTab(gBrowser.selectedTab);
+        ok(tab.selected, "the tab with ongoing sharing is selected again");
+        is(
+          window.getComputedStyle(icon).display,
+          "none",
+          "the animated sharing icon is gone after selecting the tab again"
+        );
+
+        // And finally verify the attribute is removed when closing the stream.
+        await closeStream();
+
+        // TODO(Bug 1304997): Fix the race in closeStream() and remove this
+        // TestUtils.waitForCondition().
+        await TestUtils.waitForCondition(() => !tab.getAttribute("sharing"));
+        is(
+          tab.getAttribute("sharing"),
+          "",
+          "the tab no longer has the 'sharing' attribute after closing the stream"
+        );
+      }
+
+      await getStreamAndCheckBackgroundAnim(true, true, "camera");
+      await getStreamAndCheckBackgroundAnim(false, true, "camera");
+      await getStreamAndCheckBackgroundAnim(true, false, "microphone");
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_by_device_id.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_by_device_id.js
new file mode 100644
index 0000000000..3e5ca0668a
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_by_device_id.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+/**
+ * Utility function that should be called after a request for a device
+ * has been made. This function will allow sharing that device, and then
+ * immediately close the stream.
+ */
+async function allowStreamsThenClose() {
+  let observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+  let observerPromise2 = expectObserverCalled("recording-device-events");
+  await promiseMessage("ok", () => {
+    PopupNotifications.panel.firstElementChild.button.click();
+  });
+  await observerPromise1;
+  await observerPromise2;
+
+  await closeStream();
+}
+
+/**
+ * Tests that if a site requests a particular device by ID, that
+ * the Permission Panel menulist for that device shows only that
+ * device and is disabled.
+ */
+add_task(async function test_get_user_media_by_device_id() {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+
+  let devices = await navigator.mediaDevices.enumerateDevices();
+  let audioId = devices
+    .filter(d => d.kind == "audioinput")
+    .map(d => d.deviceId)[0];
+  let videoId = devices
+    .filter(d => d.kind == "videoinput")
+    .map(d => d.deviceId)[0];
+
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let promise = promisePopupNotificationShown("webRTC-shareDevices");
+    let observerPromise = expectObserverCalled("getUserMedia:request");
+    await promiseRequestDevice({ deviceId: { exact: audioId } });
+    await promise;
+    await observerPromise;
+    checkDeviceSelectors(["microphone"]);
+
+    await allowStreamsThenClose();
+
+    promise = promisePopupNotificationShown("webRTC-shareDevices");
+    observerPromise = expectObserverCalled("getUserMedia:request");
+    await promiseRequestDevice(false, { deviceId: { exact: videoId } });
+    await promise;
+    await observerPromise;
+    checkDeviceSelectors(["camera"]);
+
+    await allowStreamsThenClose();
+
+    promise = promisePopupNotificationShown("webRTC-shareDevices");
+    observerPromise = expectObserverCalled("getUserMedia:request");
+    await promiseRequestDevice(
+      { deviceId: { exact: audioId } },
+      { deviceId: { exact: videoId } }
+    );
+    await promise;
+    await observerPromise;
+    checkDeviceSelectors(["microphone", "camera"]);
+    await allowStreamsThenClose();
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_default_permissions.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_default_permissions.js
new file mode 100644
index 0000000000..e6464fd4aa
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_default_permissions.js
@@ -0,0 +1,209 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const CAMERA_PREF = "permissions.default.camera";
+const MICROPHONE_PREF = "permissions.default.microphone";
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+video: globally blocking camera",
+    run: async function checkAudioVideo() {
+      Services.prefs.setIntPref(CAMERA_PREF, SitePermissions.BLOCK);
+
+      // Requesting audio+video shouldn't work.
+      await Promise.all([
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+        expectObserverCalled("recording-window-ended"),
+        promiseMessage(permissionError),
+        promiseRequestDevice(true, true),
+      ]);
+      await checkNotSharing();
+
+      // Requesting only video shouldn't work.
+      await Promise.all([
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+        expectObserverCalled("recording-window-ended"),
+        promiseMessage(permissionError),
+        promiseRequestDevice(false, true),
+      ]);
+      await checkNotSharing();
+
+      // Requesting audio should work.
+      const observerPromise = expectObserverCalled("getUserMedia:request");
+      const promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareMicrophone-notification-icon",
+        "anchored to mic icon"
+      );
+      checkDeviceSelectors(["microphone"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true });
+      await closeStream();
+      Services.prefs.clearUserPref(CAMERA_PREF);
+    },
+  },
+
+  {
+    desc: "getUserMedia video: globally blocking camera + local exception",
+    run: async function checkAudioVideo() {
+      let browser = gBrowser.selectedBrowser;
+      Services.prefs.setIntPref(CAMERA_PREF, SitePermissions.BLOCK);
+      // Overwrite the permission for that URI, requesting video should work again.
+      PermissionTestUtils.add(
+        browser.currentURI,
+        "camera",
+        Services.perms.ALLOW_ACTION
+      );
+
+      // Requesting video should work.
+      let indicator = promiseIndicatorWindow();
+      let promises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+
+      let promise = promiseMessage("ok");
+      await promiseRequestDevice(false, true);
+      await promise;
+
+      await Promise.all(promises);
+      await indicator;
+      await checkSharingUI({ video: true }, undefined, undefined, {
+        video: { scope: SitePermissions.SCOPE_PERSISTENT },
+      });
+      await closeStream();
+
+      PermissionTestUtils.remove(browser.currentURI, "camera");
+      Services.prefs.clearUserPref(CAMERA_PREF);
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: globally blocking microphone",
+    run: async function checkAudioVideo() {
+      Services.prefs.setIntPref(MICROPHONE_PREF, SitePermissions.BLOCK);
+
+      // Requesting audio+video shouldn't work.
+      await Promise.all([
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+        expectObserverCalled("recording-window-ended"),
+        promiseMessage(permissionError),
+        promiseRequestDevice(true, true),
+      ]);
+      await checkNotSharing();
+
+      // Requesting only audio shouldn't work.
+      await Promise.all([
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+        expectObserverCalled("recording-window-ended"),
+        promiseMessage(permissionError),
+        promiseRequestDevice(true),
+      ]);
+
+      // Requesting video should work.
+      const observerPromise = expectObserverCalled("getUserMedia:request");
+      const promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareDevices-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true });
+      await closeStream();
+      Services.prefs.clearUserPref(MICROPHONE_PREF);
+    },
+  },
+
+  {
+    desc: "getUserMedia audio: globally blocking microphone + local exception",
+    run: async function checkAudioVideo() {
+      let browser = gBrowser.selectedBrowser;
+      Services.prefs.setIntPref(MICROPHONE_PREF, SitePermissions.BLOCK);
+      // Overwrite the permission for that URI, requesting video should work again.
+      PermissionTestUtils.add(
+        browser.currentURI,
+        "microphone",
+        Services.perms.ALLOW_ACTION
+      );
+
+      // Requesting audio should work.
+      let indicator = promiseIndicatorWindow();
+      let promises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+      let promise = promiseMessage("ok");
+      await promiseRequestDevice(true);
+      await promise;
+
+      await Promise.all(promises);
+      await indicator;
+      await checkSharingUI({ audio: true }, undefined, undefined, {
+        audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+      });
+      await closeStream();
+
+      PermissionTestUtils.remove(browser.currentURI, "microphone");
+      Services.prefs.clearUserPref(MICROPHONE_PREF);
+    },
+  },
+];
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_grace.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_grace.js
new file mode 100644
index 0000000000..0df69bb9da
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_grace.js
@@ -0,0 +1,388 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+requestLongerTimeout(2);
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const SAME_ORIGIN = "https://example.com";
+const CROSS_ORIGIN = "https://example.org";
+
+const PATH = "/browser/browser/base/content/test/webrtc/get_user_media.html";
+const PATH2 = "/browser/browser/base/content/test/webrtc/get_user_media2.html";
+
+const GRACE_PERIOD_MS = 3000;
+const WAIT_PERIOD_MS = GRACE_PERIOD_MS + 500;
+
+// We're inherently testing timeouts (grace periods)
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
+const perms = SitePermissions;
+
+// These tests focus on camera and microphone, so we define some helpers.
+
+async function prompt(audio, video) {
+  let observerPromise = expectObserverCalled("getUserMedia:request");
+  let promise = promisePopupNotificationShown("webRTC-shareDevices");
+  await promiseRequestDevice(audio, video);
+  await promise;
+  await observerPromise;
+  const expectedDeviceSelectorTypes = [
+    audio && "microphone",
+    video && "camera",
+  ].filter(x => x);
+  checkDeviceSelectors(expectedDeviceSelectorTypes);
+}
+
+async function allow(audio, video) {
+  let indicator = promiseIndicatorWindow();
+  let observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+  let observerPromise2 = expectObserverCalled("recording-device-events");
+  await promiseMessage("ok", () => {
+    PopupNotifications.panel.firstElementChild.button.click();
+  });
+  await observerPromise1;
+  await observerPromise2;
+  Assert.deepEqual(
+    Object.assign({ audio: false, video: false }, await getMediaCaptureState()),
+    { audio, video },
+    `expected ${video ? "camera " : ""} ${audio ? "microphone " : ""}shared`
+  );
+  await indicator;
+  await checkSharingUI({ audio, video });
+}
+
+async function deny(action) {
+  let observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+  let observerPromise2 = expectObserverCalled("recording-window-ended");
+  await promiseMessage(permissionError, () => {
+    activateSecondaryAction(action);
+  });
+  await observerPromise1;
+  await observerPromise2;
+  await checkNotSharing();
+}
+
+async function noPrompt(audio, video) {
+  let observerPromises = [
+    expectObserverCalled("getUserMedia:request"),
+    expectObserverCalled("getUserMedia:response:allow"),
+    expectObserverCalled("recording-device-events"),
+  ];
+  let promise = promiseMessage("ok");
+  await promiseRequestDevice(audio, video);
+  await promise;
+  await Promise.all(observerPromises);
+  await promiseNoPopupNotification("webRTC-shareDevices");
+  Assert.deepEqual(
+    Object.assign({ audio: false, video: false }, await getMediaCaptureState()),
+    { audio, video },
+    `expected ${video ? "camera " : ""} ${audio ? "microphone " : ""}shared`
+  );
+  await checkSharingUI({ audio, video });
+}
+
+async function navigate(browser, url) {
+  await disableObserverVerification();
+  let loaded = BrowserTestUtils.browserLoaded(browser, false, url);
+  await SpecialPowers.spawn(
+    browser,
+    [url],
+    u => (content.document.location = u)
+  );
+  await loaded;
+  await enableObserverVerification();
+}
+
+var gTests = [
+  {
+    desc: "getUserMedia camera+mic survives track.stop but not past grace",
+    run: async function checkAudioVideoGracePastStop() {
+      await prompt(true, true);
+      await allow(true, true);
+
+      info(
+        "After closing all streams, gUM(camera+mic) returns a stream " +
+          "without prompting within grace period."
+      );
+      await closeStream();
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, true);
+
+      info(
+        "After closing all streams, gUM(mic) returns a stream " +
+          "without prompting within grace period."
+      );
+      await closeStream();
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, false);
+
+      info(
+        "After closing all streams, gUM(camera) returns a stream " +
+          "without prompting within grace period."
+      );
+      await closeStream();
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(false, true);
+
+      info("gUM(screen) still causes a prompt.");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise;
+      perms.removeFromPrincipal(null, "screen", gBrowser.selectedBrowser);
+
+      await closeStream();
+      info("Closed stream. Waiting past grace period.");
+      await checkNotSharingWithinGracePeriod();
+      await wait(WAIT_PERIOD_MS);
+      await checkNotSharing();
+
+      info("After grace period expires, gUM(camera) causes a prompt.");
+      await prompt(false, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+
+      info("After grace period expires, gUM(mic) causes a prompt.");
+      await prompt(true, false);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+    },
+  },
+
+  {
+    desc: "getUserMedia camera+mic survives page reload but not past grace",
+    run: async function checkAudioVideoGracePastReload(browser) {
+      await prompt(true, true);
+      await allow(true, true);
+      await closeStream();
+
+      await reloadFromContent();
+      info(
+        "After page reload, gUM(camera+mic) returns a stream " +
+          "without prompting within grace period."
+      );
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, true);
+      await closeStream();
+
+      await reloadAsUser();
+      info(
+        "After user page reload, gUM(camera+mic) returns a stream " +
+          "without prompting within grace period."
+      );
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, true);
+
+      info("gUM(screen) still causes a prompt.");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise;
+      perms.removeFromPrincipal(null, "screen", gBrowser.selectedBrowser);
+
+      await closeStream();
+      info("Closed stream. Waiting past grace period.");
+      await checkNotSharingWithinGracePeriod();
+      await wait(WAIT_PERIOD_MS);
+      await checkNotSharing();
+
+      info("After grace period expires, gUM(camera) causes a prompt.");
+      await prompt(false, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+
+      info("After grace period expires, gUM(mic) causes a prompt.");
+      await prompt(true, false);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+    },
+  },
+
+  {
+    desc: "getUserMedia camera+mic grace period does not carry over to new tab",
+    run: async function checkAudioVideoGraceEndsNewTab() {
+      await prompt(true, true);
+      await allow(true, true);
+
+      info("Open same page in a new tab");
+      await disableObserverVerification();
+      await BrowserTestUtils.withNewTab(SAME_ORIGIN + PATH, async browser => {
+        info("In new tab, gUM(camera+mic) causes a prompt.");
+        await prompt(true, true);
+      });
+      info("Closed tab");
+      await enableObserverVerification();
+      await closeStream();
+      info("Closed stream. Waiting past grace period.");
+      await checkNotSharingWithinGracePeriod();
+      await wait(WAIT_PERIOD_MS);
+      await checkNotSharing();
+
+      info("After grace period expires, gUM(camera+mic) causes a prompt.");
+      await prompt(true, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+    },
+  },
+
+  {
+    desc: "getUserMedia camera+mic survives navigation but not past grace",
+    run: async function checkAudioVideoGracePastNavigation(browser) {
+      // Use longer grace period in this test to accommodate navigation
+      const LONG_GRACE_PERIOD_MS = 9000;
+      const LONG_WAIT_PERIOD_MS = LONG_GRACE_PERIOD_MS + 500;
+      await SpecialPowers.pushPrefEnv({
+        set: [
+          ["privacy.webrtc.deviceGracePeriodTimeoutMs", LONG_GRACE_PERIOD_MS],
+        ],
+      });
+      await prompt(true, true);
+      await allow(true, true);
+      await closeStream();
+
+      info("Navigate to a second same-origin page");
+      await navigate(browser, SAME_ORIGIN + PATH2);
+      info(
+        "After navigating to second same-origin page, gUM(camera+mic) " +
+          "returns a stream without prompting within grace period."
+      );
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, true);
+      await closeStream();
+
+      info("Closed stream. Waiting past grace period.");
+      await checkNotSharingWithinGracePeriod();
+      await wait(LONG_WAIT_PERIOD_MS);
+      await checkNotSharing();
+
+      info("After grace period expires, gUM(camera+mic) causes a prompt.");
+      await prompt(true, true);
+      await allow(true, true);
+
+      info("Navigate to a different-origin page");
+      await navigate(browser, CROSS_ORIGIN + PATH2);
+      info(
+        "After navigating to a different-origin page, gUM(camera+mic) " +
+          "causes a prompt."
+      );
+      await prompt(true, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+
+      info("Navigate back to the first page");
+      await navigate(browser, SAME_ORIGIN + PATH);
+      info(
+        "After navigating back to the first page, gUM(camera+mic) " +
+          "returns a stream without prompting within grace period."
+      );
+      await checkNotSharingWithinGracePeriod();
+      await noPrompt(true, true);
+      await closeStream();
+      info("Closed stream. Waiting past grace period.");
+      await checkNotSharingWithinGracePeriod();
+      await wait(LONG_WAIT_PERIOD_MS);
+      await checkNotSharing();
+
+      info("After grace period expires, gUM(camera+mic) causes a prompt.");
+      await prompt(true, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+    },
+  },
+
+  {
+    desc: "getUserMedia camera+mic grace period cleared on permission block",
+    run: async function checkAudioVideoGraceEndsNewTab(browser) {
+      await SpecialPowers.pushPrefEnv({
+        set: [["privacy.webrtc.deviceGracePeriodTimeoutMs", 10000]],
+      });
+      info("Set up longer camera grace period.");
+      await prompt(false, true);
+      await allow(false, true);
+      await closeStream();
+      let principal = gBrowser.selectedBrowser.contentPrincipal;
+      info("Request both to get prompted so we can block both.");
+      await prompt(true, true);
+      // We need to remember this decision to set a block permission here and not just 'Not now' the request, see Bug:1609578
+      await deny(kActionNever);
+      // Clear the block so we can prompt again.
+      perms.removeFromPrincipal(principal, "camera", gBrowser.selectedBrowser);
+      perms.removeFromPrincipal(
+        principal,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      info("Revoking permission clears camera grace period.");
+      await prompt(false, true);
+      await deny(kActionDeny);
+      perms.removeFromPrincipal(null, "camera", gBrowser.selectedBrowser);
+
+      info("Set up longer microphone grace period.");
+      await prompt(true, false);
+      await allow(true, false);
+      await closeStream();
+
+      info("Request both to get prompted so we can block both.");
+      await prompt(true, true);
+      // We need to remember this decision to be able to set a block permission here
+      await deny(kActionNever);
+      perms.removeFromPrincipal(principal, "camera", gBrowser.selectedBrowser);
+      perms.removeFromPrincipal(
+        principal,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      info("Revoking permission clears microphone grace period.");
+      await prompt(true, false);
+      // We need to remember this decision to be able to set a block permission here
+      await deny(kActionNever);
+      perms.removeFromPrincipal(null, "microphone", gBrowser.selectedBrowser);
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.webrtc.deviceGracePeriodTimeoutMs", GRACE_PERIOD_MS]],
+  });
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_in_frame.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_frame.js
new file mode 100644
index 0000000000..81e04cebce
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_frame.js
@@ -0,0 +1,775 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+SpecialPowers.pushPrefEnv({
+  set: [["permissions.delegation.enabled", true]],
+});
+
+// This test has been seen timing out locally in non-opt debug builds.
+requestLongerTimeout(2);
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+video",
+    run: async function checkAudioVideo(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareDevices-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["microphone", "camera"]);
+      is(
+        PopupNotifications.panel.firstElementChild.getAttribute("popupid"),
+        "webRTC-shareDevices",
+        "panel using devices icon"
+      );
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+      await closeStream(false, frame1ID, undefined, frame1BC, frame1ObserveBC);
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: stop sharing",
+    run: async function checkStopSharing(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        activateSecondaryAction(kActionAlways);
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true }, undefined, undefined, {
+        video: { scope: SitePermissions.SCOPE_PERSISTENT },
+        audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+      });
+
+      let uri = Services.io.newURI("https://example.com/");
+      is(
+        PermissionTestUtils.testExactPermission(uri, "microphone"),
+        Services.perms.ALLOW_ACTION,
+        "microphone persistently allowed"
+      );
+      is(
+        PermissionTestUtils.testExactPermission(uri, "camera"),
+        Services.perms.ALLOW_ACTION,
+        "camera persistently allowed"
+      );
+
+      await stopSharing("camera", false, frame1ObserveBC);
+
+      // The persistent permissions for the frame should have been removed.
+      is(
+        PermissionTestUtils.testExactPermission(uri, "microphone"),
+        Services.perms.UNKNOWN_ACTION,
+        "microphone not persistently allowed"
+      );
+      is(
+        PermissionTestUtils.testExactPermission(uri, "camera"),
+        Services.perms.UNKNOWN_ACTION,
+        "camera not persistently allowed"
+      );
+
+      // the stream is already closed, but this will do some cleanup anyway
+      await closeStream(true, frame1ID, undefined, frame1BC, frame1ObserveBC);
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: Revoking active devices in frame does not add grace period.",
+    run: async function checkStopSharingGracePeriod(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // Stop sharing for camera and test that we stopped sharing.
+      await stopSharing("camera", false, frame1ObserveBC);
+
+      // There shouldn't be any grace period permissions at this point.
+      ok(
+        !SitePermissions.getAllForBrowser(aBrowser).length,
+        "Should not set any permissions."
+      );
+
+      // A new request should result in a prompt.
+      observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let notificationPromise = promisePopupNotificationShown(
+        "webRTC-shareDevices"
+      );
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await notificationPromise;
+      await observerPromise;
+
+      let denyPromise = expectObserverCalled(
+        "getUserMedia:response:deny",
+        1,
+        frame1ObserveBC
+      );
+      let recordingEndedPromise = expectObserverCalled(
+        "recording-window-ended",
+        1,
+        frame1ObserveBC
+      );
+      const permissionError =
+        "error: NotAllowedError: The request is not allowed " +
+        "by the user agent or the platform in the current context.";
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await denyPromise;
+      await recordingEndedPromise;
+
+      // Clean up the temporary blocks from the prompt deny.
+      SitePermissions.clearTemporaryBlockPermissions(aBrowser);
+
+      // the stream is already closed, but this will do some cleanup anyway
+      await closeStream(true, frame1ID, undefined, frame1BC, frame1ObserveBC);
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: reloading the frame removes all sharing UI",
+    run: async function checkReloading(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      let indicator = promiseIndicatorWindow();
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // Disable while loading a new page
+      await disableObserverVerification();
+
+      info("reloading the frame");
+      let promises = [
+        expectObserverCalledOnClose(
+          "recording-device-stopped",
+          1,
+          frame1ObserveBC
+        ),
+        expectObserverCalledOnClose(
+          "recording-device-events",
+          1,
+          frame1ObserveBC
+        ),
+        expectObserverCalledOnClose(
+          "recording-window-ended",
+          1,
+          frame1ObserveBC
+        ),
+      ];
+      await promiseReloadFrame(frame1ID, frame1BC);
+      await Promise.all(promises);
+
+      await enableObserverVerification();
+
+      await checkNotSharing();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: reloading the frame removes prompts",
+    run: async function checkReloadingRemovesPrompts(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      info("reloading the frame");
+      promise = expectObserverCalledOnClose(
+        "recording-window-ended",
+        1,
+        frame1ObserveBC
+      );
+      await promiseReloadFrame(frame1ID, frame1BC);
+      await promise;
+      await promiseNoPopupNotification("webRTC-shareDevices");
+
+      await checkNotSharing();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: with two frames sharing at the same time, sharing UI shows all shared devices",
+    run: async function checkFrameOverridingSharingUI(aBrowser, aSubFrames) {
+      // This tests an edge case discovered in bug 1440356 that works like this
+      // - Share audio and video in iframe 1.
+      // - Share only video in iframe 2.
+      // The WebRTC UI should still show both video and audio indicators.
+
+      let bcsAndFrameIds = await getBrowsingContextsAndFrameIdsForSubFrames(
+        aBrowser.browsingContext,
+        aSubFrames
+      );
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = bcsAndFrameIds[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // Check that requesting a new device from a different frame
+      // doesn't override sharing UI.
+      let {
+        bc: frame2BC,
+        id: frame2ID,
+        observeBC: frame2ObserveBC,
+      } = bcsAndFrameIds[1];
+
+      observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame2ObserveBC
+      );
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, frame2ID, undefined, frame2BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["camera"]);
+
+      observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame2ObserveBC
+      );
+      observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame2ObserveBC
+      );
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await checkSharingUI({ video: true, audio: true });
+
+      // Check that ending the stream with the other frame
+      // doesn't override sharing UI.
+
+      observerPromise = expectObserverCalledOnClose(
+        "recording-window-ended",
+        1,
+        frame2ObserveBC
+      );
+      promise = expectObserverCalledOnClose(
+        "recording-device-events",
+        1,
+        frame2ObserveBC
+      );
+      await promiseReloadFrame(frame2ID, frame2BC);
+      await promise;
+
+      await observerPromise;
+      await checkSharingUI({ video: true, audio: true });
+
+      await closeStream(false, frame1ID, undefined, frame1BC, frame1ObserveBC);
+      await checkNotSharing();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: reloading a frame updates the sharing UI",
+    run: async function checkUpdateWhenReloading(aBrowser, aSubFrames) {
+      // We'll share only the cam in the first frame, then share both in the
+      // second frame, then reload the second frame. After each step, we'll check
+      // the UI is in the correct state.
+      let bcsAndFrameIds = await getBrowsingContextsAndFrameIdsForSubFrames(
+        aBrowser.browsingContext,
+        aSubFrames
+      );
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = bcsAndFrameIds[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: false });
+
+      let {
+        bc: frame2BC,
+        id: frame2ID,
+        observeBC: frame2ObserveBC,
+      } = bcsAndFrameIds[1];
+
+      observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame2ObserveBC
+      );
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame2ID, undefined, frame2BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame2ObserveBC
+      );
+      observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame2ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await checkSharingUI({ video: true, audio: true });
+
+      info("reloading the second frame");
+
+      observerPromise1 = expectObserverCalledOnClose(
+        "recording-device-events",
+        1,
+        frame2ObserveBC
+      );
+      observerPromise2 = expectObserverCalledOnClose(
+        "recording-window-ended",
+        1,
+        frame2ObserveBC
+      );
+      await promiseReloadFrame(frame2ID, frame2BC);
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkSharingUI({ video: true, audio: false });
+
+      await closeStream(false, frame1ID, undefined, frame1BC, frame1ObserveBC);
+      await checkNotSharing();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: reloading the top level page removes all sharing UI",
+    run: async function checkReloading(aBrowser, aSubFrames) {
+      let {
+        bc: frame1BC,
+        id: frame1ID,
+        observeBC: frame1ObserveBC,
+      } = (
+        await getBrowsingContextsAndFrameIdsForSubFrames(
+          aBrowser.browsingContext,
+          aSubFrames
+        )
+      )[0];
+
+      let observerPromise = expectObserverCalled(
+        "getUserMedia:request",
+        1,
+        frame1ObserveBC
+      );
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow",
+        1,
+        frame1ObserveBC
+      );
+      let observerPromise2 = expectObserverCalled(
+        "recording-device-events",
+        1,
+        frame1ObserveBC
+      );
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      await reloadAndAssertClosedStreams();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: closing a window with two frames sharing at the same time, closes the indicator",
+    skipObserverVerification: true,
+    run: async function checkFrameIndicatorClosedUI(aBrowser, aSubFrames) {
+      // This tests a case where the indicator didn't close when audio/video is
+      // shared in two subframes and then the tabs are closed.
+
+      let tabsToRemove = [gBrowser.selectedTab];
+
+      for (let t = 0; t < 2; t++) {
+        let {
+          bc: frame1BC,
+          id: frame1ID,
+          observeBC: frame1ObserveBC,
+        } = (
+          await getBrowsingContextsAndFrameIdsForSubFrames(
+            gBrowser.selectedBrowser.browsingContext,
+            aSubFrames
+          )
+        )[0];
+
+        let observerPromise = expectObserverCalled(
+          "getUserMedia:request",
+          1,
+          frame1ObserveBC
+        );
+        let promise = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(true, true, frame1ID, undefined, frame1BC);
+        await promise;
+        await observerPromise;
+        checkDeviceSelectors(["microphone", "camera"]);
+
+        // During the second pass, the indicator is already open.
+        let indicator = t == 0 ? promiseIndicatorWindow() : Promise.resolve();
+
+        let observerPromise1 = expectObserverCalled(
+          "getUserMedia:response:allow",
+          1,
+          frame1ObserveBC
+        );
+        let observerPromise2 = expectObserverCalled(
+          "recording-device-events",
+          1,
+          frame1ObserveBC
+        );
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await observerPromise1;
+        await observerPromise2;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+
+        await indicator;
+        await checkSharingUI({ video: true, audio: true });
+
+        // The first time around, open another tab with the same uri.
+        // The second time, just open a normal test tab.
+        let uri = t == 0 ? gBrowser.selectedBrowser.currentURI.spec : undefined;
+        tabsToRemove.push(
+          await BrowserTestUtils.openNewForegroundTab(gBrowser, uri)
+        );
+      }
+
+      BrowserTestUtils.removeTab(tabsToRemove[0]);
+      BrowserTestUtils.removeTab(tabsToRemove[1]);
+
+      await checkNotSharing();
+    },
+  },
+];
+
+add_task(async function test_inprocess() {
+  await runTests(gTests, {
+    relativeURI: "get_user_media_in_frame.html",
+    subFrames: { frame1: {}, frame2: {} },
+  });
+});
+
+add_task(async function test_outofprocess() {
+  const origin1 = encodeURI("https://test1.example.org");
+  const origin2 = encodeURI("https://www.mozilla.org:443");
+  const query = `origin=${origin1}&origin=${origin2}`;
+  const observe = SpecialPowers.useRemoteSubframes;
+  await runTests(gTests, {
+    relativeURI: `get_user_media_in_frame.html?${query}`,
+    subFrames: { frame1: { observe }, frame2: { observe } },
+  });
+});
+
+add_task(async function test_inprocess_in_outofprocess() {
+  const oopOrigin = encodeURI("https://www.mozilla.org");
+  const sameOrigin = encodeURI("https://example.com");
+  const query = `origin=${oopOrigin}&nested=${sameOrigin}&nested=${sameOrigin}`;
+  await runTests(gTests, {
+    relativeURI: `get_user_media_in_frame.html?${query}`,
+    subFrames: {
+      frame1: {
+        noTest: true,
+        children: { frame1: {}, frame2: {} },
+      },
+    },
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame.js
new file mode 100644
index 0000000000..8c0b0476f3
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame.js
@@ -0,0 +1,798 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const PromptResult = {
+  ALLOW: "allow",
+  DENY: "deny",
+  PROMPT: "prompt",
+};
+
+const Perms = Services.perms;
+
+async function promptNoDelegate(aThirdPartyOrgin, audio = true, video = true) {
+  // Persistent allowed first party origin
+  const uri = gBrowser.selectedBrowser.documentURI;
+  if (audio) {
+    PermissionTestUtils.add(uri, "microphone", Services.perms.ALLOW_ACTION);
+  }
+  if (video) {
+    PermissionTestUtils.add(uri, "camera", Services.perms.ALLOW_ACTION);
+  }
+
+  // Check that we get a prompt.
+  const observerPromise = expectObserverCalled("getUserMedia:request");
+  const promise = promisePopupNotificationShown("webRTC-shareDevices");
+  await promiseRequestDevice(audio, video, "frame4");
+  await promise;
+  await observerPromise;
+
+  // The 'Remember this decision' checkbox is hidden.
+  const notification = PopupNotifications.panel.firstElementChild;
+  const checkbox = notification.checkbox;
+  ok(!!checkbox, "checkbox is present");
+  ok(checkbox.hidden, "checkbox is not visible");
+  ok(!checkbox.checked, "checkbox not checked");
+
+  // Check the label of the notification should be the first party
+  is(
+    PopupNotifications.getNotification("webRTC-shareDevices").options.name,
+    uri.host,
+    "Use first party's origin"
+  );
+
+  // Check the secondName of the notification should be the third party
+  is(
+    PopupNotifications.getNotification("webRTC-shareDevices").options
+      .secondName,
+    aThirdPartyOrgin,
+    "Use third party's origin as secondName"
+  );
+
+  let indicator = promiseIndicatorWindow();
+  let observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+  let observerPromise2 = expectObserverCalled("recording-device-events");
+  await promiseMessage("ok", () =>
+    EventUtils.synthesizeMouseAtCenter(notification.button, {})
+  );
+  await observerPromise1;
+  await observerPromise2;
+  let state = await getMediaCaptureState();
+  is(
+    !!state.audio,
+    audio,
+    `expected microphone to be ${audio ? "" : "not"} shared`
+  );
+  is(
+    !!state.video,
+    video,
+    `expected camera to be ${video ? "" : "not"} shared`
+  );
+  await indicator;
+  await checkSharingUI({ audio, video }, undefined, undefined, {
+    video: { scope: SitePermissions.SCOPE_PERSISTENT },
+    audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+  });
+
+  // Cleanup.
+  await closeStream(false, "frame4");
+
+  PermissionTestUtils.remove(uri, "camera");
+  PermissionTestUtils.remove(uri, "microphone");
+}
+
+async function promptNoDelegateScreenSharing(aThirdPartyOrgin) {
+  // Persistent allow screen sharing
+  const uri = gBrowser.selectedBrowser.documentURI;
+  PermissionTestUtils.add(uri, "screen", Services.perms.ALLOW_ACTION);
+
+  const observerPromise = expectObserverCalled("getUserMedia:request");
+  const promise = promisePopupNotificationShown("webRTC-shareDevices");
+  await promiseRequestDevice(false, true, "frame4", "screen");
+  await promise;
+  await observerPromise;
+
+  checkDeviceSelectors(["screen"]);
+  const notification = PopupNotifications.panel.firstElementChild;
+
+  // The 'Remember this decision' checkbox is hidden.
+  const checkbox = notification.checkbox;
+  ok(!!checkbox, "checkbox is present");
+
+  if (ALLOW_SILENCING_NOTIFICATIONS) {
+    ok(!checkbox.hidden, "Notification silencing checkbox is visible");
+  } else {
+    ok(checkbox.hidden, "checkbox is not visible");
+  }
+
+  ok(!checkbox.checked, "checkbox not checked");
+
+  // Check the label of the notification should be the first party
+  is(
+    PopupNotifications.getNotification("webRTC-shareDevices").options.name,
+    uri.host,
+    "Use first party's origin"
+  );
+
+  // Check the secondName of the notification should be the third party
+  is(
+    PopupNotifications.getNotification("webRTC-shareDevices").options
+      .secondName,
+    aThirdPartyOrgin,
+    "Use third party's origin as secondName"
+  );
+
+  const menulist = document.getElementById("webRTC-selectWindow-menulist");
+  const count = menulist.itemCount;
+  menulist.getItemAtIndex(count - 1).doCommand();
+  ok(!notification.button.disabled, "Allow button is enabled");
+
+  const indicator = promiseIndicatorWindow();
+  const observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+  const observerPromise2 = expectObserverCalled("recording-device-events");
+  await promiseMessage("ok", () =>
+    EventUtils.synthesizeMouseAtCenter(notification.button, {})
+  );
+  await observerPromise1;
+  await observerPromise2;
+  Assert.deepEqual(
+    await getMediaCaptureState(),
+    { screen: "Screen" },
+    "expected screen to be shared"
+  );
+
+  await indicator;
+  await checkSharingUI({ screen: "Screen" }, undefined, undefined, {
+    screen: { scope: SitePermissions.SCOPE_PERSISTENT },
+  });
+  await closeStream(false, "frame4");
+
+  PermissionTestUtils.remove(uri, "screen");
+}
+
+var gTests = [
+  {
+    desc: "'Always Allow' enabled on third party pages, when origin is explicitly allowed",
+    run: async function checkNoAlwaysOnThirdParty() {
+      // Initially set both permissions to 'prompt'.
+      const uri = gBrowser.selectedBrowser.documentURI;
+      PermissionTestUtils.add(uri, "microphone", Services.perms.PROMPT_ACTION);
+      PermissionTestUtils.add(uri, "camera", Services.perms.PROMPT_ACTION);
+
+      const observerPromise = expectObserverCalled("getUserMedia:request");
+      const promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      // The 'Remember this decision' checkbox is visible.
+      const notification = PopupNotifications.panel.firstElementChild;
+      const checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.hidden, "checkbox is visible");
+      ok(!checkbox.checked, "checkbox not checked");
+
+      // Check the label of the notification should be the first party
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").options.name,
+        uri.host,
+        "Use first party's origin"
+      );
+
+      const indicator = promiseIndicatorWindow();
+      const observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      const observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () =>
+        EventUtils.synthesizeMouseAtCenter(notification.button, {})
+      );
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+
+      // Cleanup.
+      await closeStream(false, "frame1");
+      PermissionTestUtils.remove(uri, "camera");
+      PermissionTestUtils.remove(uri, "microphone");
+    },
+  },
+  {
+    desc: "'Always Allow' disabled when sharing screen in third party iframes, when origin is explicitly allowed",
+    run: async function checkScreenSharing() {
+      const observerPromise = expectObserverCalled("getUserMedia:request");
+      const promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, "frame1", "screen");
+      await promise;
+      await observerPromise;
+
+      checkDeviceSelectors(["screen"]);
+      const notification = PopupNotifications.panel.firstElementChild;
+
+      // The 'Remember this decision' checkbox is visible.
+      const checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.hidden, "checkbox is visible");
+      ok(!checkbox.checked, "checkbox not checked");
+
+      const menulist = document.getElementById("webRTC-selectWindow-menulist");
+      const count = menulist.itemCount;
+      ok(
+        count >= 4,
+        "There should be the 'Select Window or Screen' item, a separator and at least one window and one screen"
+      );
+
+      const noWindowOrScreenItem = menulist.getItemAtIndex(0);
+      ok(
+        noWindowOrScreenItem.hasAttribute("selected"),
+        "the 'Select Window or Screen' item is selected"
+      );
+      is(
+        menulist.selectedItem,
+        noWindowOrScreenItem,
+        "'Select Window or Screen' is the selected item"
+      );
+      is(menulist.value, "-1", "no window or screen is selected by default");
+      ok(
+        noWindowOrScreenItem.disabled,
+        "'Select Window or Screen' item is disabled"
+      );
+      ok(notification.button.disabled, "Allow button is disabled");
+      ok(
+        notification.hasAttribute("invalidselection"),
+        "Notification is marked as invalid"
+      );
+
+      menulist.getItemAtIndex(count - 1).doCommand();
+      ok(!notification.button.disabled, "Allow button is enabled");
+
+      const indicator = promiseIndicatorWindow();
+      const observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      const observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () =>
+        EventUtils.synthesizeMouseAtCenter(notification.button, {})
+      );
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+      await closeStream(false, "frame1");
+    },
+  },
+
+  {
+    desc: "getUserMedia use persistent permissions from first party",
+    run: async function checkUsePersistentPermissionsFirstParty() {
+      async function checkPersistentPermission(
+        aPermission,
+        aRequestType,
+        aIframeId,
+        aExpect
+      ) {
+        info(
+          `Test persistent permission ${aPermission} type ${aRequestType} expect ${aExpect}`
+        );
+        const uri = gBrowser.selectedBrowser.documentURI;
+        // Persistent allow/deny for first party uri
+        PermissionTestUtils.add(uri, aRequestType, aPermission);
+
+        let audio = aRequestType == "microphone";
+        let video = aRequestType == "camera";
+        const screen = aRequestType == "screen" ? "screen" : undefined;
+        if (screen) {
+          audio = false;
+          video = true;
+        }
+        if (aExpect == PromptResult.PROMPT) {
+          // Check that we get a prompt.
+          const observerPromise = expectObserverCalled("getUserMedia:request");
+          const observerPromise1 = expectObserverCalled(
+            "getUserMedia:response:deny"
+          );
+          const observerPromise2 = expectObserverCalled(
+            "recording-window-ended"
+          );
+          const promise = promisePopupNotificationShown("webRTC-shareDevices");
+          await promiseRequestDevice(audio, video, aIframeId, screen);
+          await promise;
+          await observerPromise;
+
+          // Check the label of the notification should be the first party
+          is(
+            PopupNotifications.getNotification("webRTC-shareDevices").options
+              .name,
+            uri.host,
+            "Use first party's origin"
+          );
+
+          // Deny the request to cleanup...
+          await promiseMessage(permissionError, () => {
+            activateSecondaryAction(kActionDeny);
+          });
+          await observerPromise1;
+          await observerPromise2;
+          let browser = gBrowser.selectedBrowser;
+          SitePermissions.removeFromPrincipal(null, aRequestType, browser);
+        } else if (aExpect == PromptResult.ALLOW) {
+          const observerPromise = expectObserverCalled("getUserMedia:request");
+          const observerPromise1 = expectObserverCalled(
+            "getUserMedia:response:allow"
+          );
+          const observerPromise2 = expectObserverCalled(
+            "recording-device-events"
+          );
+          const promise = promiseMessage("ok");
+          await promiseRequestDevice(audio, video, aIframeId, screen);
+          await promise;
+          await observerPromise;
+
+          await promiseNoPopupNotification("webRTC-shareDevices");
+          await observerPromise1;
+          await observerPromise2;
+
+          let expected = {};
+          if (audio) {
+            expected.audio = audio;
+          }
+          if (video) {
+            expected.video = video;
+          }
+
+          Assert.deepEqual(
+            await getMediaCaptureState(),
+            expected,
+            "expected " + Object.keys(expected).join(" and ") + " to be shared"
+          );
+
+          await closeStream(false, aIframeId);
+        } else if (aExpect == PromptResult.DENY) {
+          const promises = [];
+          // frame3 disallows by feature Permissions Policy before request.
+          if (aIframeId != "frame3") {
+            promises.push(
+              expectObserverCalled("getUserMedia:request"),
+              expectObserverCalled("getUserMedia:response:deny")
+            );
+          }
+          promises.push(
+            expectObserverCalled("recording-window-ended"),
+            promiseMessage(permissionError),
+            promiseRequestDevice(audio, video, aIframeId, screen)
+          );
+          await Promise.all(promises);
+        }
+
+        PermissionTestUtils.remove(uri, aRequestType);
+      }
+
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "camera",
+        "frame1",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "camera",
+        "frame1",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "camera",
+        "frame1",
+        PromptResult.ALLOW
+      );
+
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "microphone",
+        "frame1",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "microphone",
+        "frame1",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "microphone",
+        "frame1",
+        PromptResult.ALLOW
+      );
+
+      // Wildcard attributes still get delegation when their src is unchanged.
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "camera",
+        "frame4",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "camera",
+        "frame4",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "camera",
+        "frame4",
+        PromptResult.ALLOW
+      );
+
+      // Wildcard attributes still get delegation when their src is unchanged.
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "microphone",
+        "frame4",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "microphone",
+        "frame4",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "microphone",
+        "frame4",
+        PromptResult.ALLOW
+      );
+
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "screen",
+        "frame1",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "screen",
+        "frame1",
+        PromptResult.DENY
+      );
+      // Always prompt screen sharing
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "screen",
+        "frame1",
+        PromptResult.PROMPT
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "screen",
+        "frame4",
+        PromptResult.PROMPT
+      );
+
+      // Denied by default if allow is not defined
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "camera",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "camera",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "camera",
+        "frame3",
+        PromptResult.DENY
+      );
+
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "microphone",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "microphone",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "microphone",
+        "frame3",
+        PromptResult.DENY
+      );
+
+      await checkPersistentPermission(
+        Perms.PROMPT_ACTION,
+        "screen",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.DENY_ACTION,
+        "screen",
+        "frame3",
+        PromptResult.DENY
+      );
+      await checkPersistentPermission(
+        Perms.ALLOW_ACTION,
+        "screen",
+        "frame3",
+        PromptResult.DENY
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia use temporary blocked permissions from first party",
+    run: async function checkUseTempPermissionsBlockFirstParty() {
+      async function checkTempPermission(aRequestType) {
+        let browser = gBrowser.selectedBrowser;
+        let observerPromise = expectObserverCalled("getUserMedia:request");
+        let observerPromise1 = expectObserverCalled(
+          "getUserMedia:response:deny"
+        );
+        let observerPromise2 = expectObserverCalled("recording-window-ended");
+        let promise = promisePopupNotificationShown("webRTC-shareDevices");
+        let audio = aRequestType == "microphone";
+        let video = aRequestType == "camera";
+        const screen = aRequestType == "screen" ? "screen" : undefined;
+        if (screen) {
+          audio = false;
+          video = true;
+        }
+
+        await promiseRequestDevice(audio, video, null, screen);
+        await promise;
+        await observerPromise;
+
+        // Temporarily grant/deny from top level
+        // Only need to check allow and deny temporary permissions
+        await promiseMessage(permissionError, () => {
+          activateSecondaryAction(kActionDeny);
+        });
+        await observerPromise1;
+        await observerPromise2;
+        await checkNotSharing();
+
+        observerPromise = expectObserverCalled("getUserMedia:request");
+        observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+        observerPromise2 = expectObserverCalled("recording-window-ended");
+        promise = promiseMessage(permissionError);
+        await promiseRequestDevice(audio, video, "frame1", screen);
+        await promise;
+
+        await observerPromise;
+        await observerPromise1;
+        await observerPromise2;
+
+        SitePermissions.removeFromPrincipal(null, aRequestType, browser);
+      }
+
+      // At the moment we only save temporary deny
+      await checkTempPermission("camera");
+      await checkTempPermission("microphone");
+      await checkTempPermission("screen");
+    },
+  },
+  {
+    desc: "Don't reprompt while actively sharing in maybe unsafe permission delegation",
+    run: async function checkNoRepromptNoDelegate() {
+      // Change location to ensure that we're treated as potentially unsafe.
+      await promiseChangeLocationFrame(
+        "frame4",
+        "https://test2.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"
+      );
+
+      // Check that we get a prompt.
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame4");
+      await promise;
+      await observerPromise;
+
+      // Check the secondName of the notification should be the third party
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").options
+          .secondName,
+        "test2.example.com",
+        "Use third party's origin as secondName"
+      );
+
+      const notification = PopupNotifications.panel.firstElementChild;
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () =>
+        EventUtils.synthesizeMouseAtCenter(notification.button, {})
+      );
+      await observerPromise1;
+      await observerPromise2;
+
+      let state = await getMediaCaptureState();
+      is(!!state.audio, true, "expected microphone to be shared");
+      is(!!state.video, true, "expected camera to be shared");
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+
+      // Check that we now don't get a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      promise = promiseMessage("ok");
+      await promiseRequestDevice(true, true, "frame4");
+      await promise;
+      await observerPromise;
+
+      await promiseNoPopupNotification("webRTC-shareDevices");
+      await observerPromise1;
+      await observerPromise2;
+
+      state = await getMediaCaptureState();
+      is(!!state.audio, true, "expected microphone to be shared");
+      is(!!state.video, true, "expected camera to be shared");
+      await checkSharingUI({ audio: true, video: true });
+
+      // Cleanup.
+      await closeStream(false, "frame4");
+    },
+  },
+  {
+    desc: "Change location, prompt and display both first party and third party origin in maybe unsafe permission delegation",
+    run: async function checkPromptNoDelegateChangeLoxation() {
+      await promiseChangeLocationFrame(
+        "frame4",
+        "https://test2.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"
+      );
+      await promptNoDelegate("test2.example.com");
+    },
+  },
+  {
+    desc: "Change location, prompt and display both first party and third party origin when sharing screen in unsafe permission delegation",
+    run: async function checkPromptNoDelegateScreenSharingChangeLocation() {
+      await promiseChangeLocationFrame(
+        "frame4",
+        "https://test2.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"
+      );
+      await promptNoDelegateScreenSharing("test2.example.com");
+    },
+  },
+  {
+    desc: "Prompt and display both first party and third party origin and temporary deny in frame does not change permission scope",
+    skipObserverVerification: true,
+    run: async function checkPromptBothOriginsTempDenyFrame() {
+      // Change location to ensure that we're treated as potentially unsafe.
+      await promiseChangeLocationFrame(
+        "frame4",
+        "https://test2.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"
+      );
+
+      // Persistent allowed first party origin
+      let browser = gBrowser.selectedBrowser;
+      let uri = gBrowser.selectedBrowser.documentURI;
+      let principal = Services.scriptSecurityManager.createContentPrincipal(
+        uri,
+        {}
+      );
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+
+      // Ensure that checking the 'Remember this decision'
+      let notification = PopupNotifications.panel.firstElementChild;
+      let checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.checked, "checkbox is not checked");
+      checkbox.click();
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () =>
+        EventUtils.synthesizeMouseAtCenter(notification.button, {})
+      );
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: true, video: true }, undefined, undefined, {
+        audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+        video: { scope: SitePermissions.SCOPE_PERSISTENT },
+      });
+      await closeStream(true);
+
+      // Check that we get a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame4");
+      await promise;
+      await observerPromise;
+
+      // The 'Remember this decision' checkbox is hidden.
+      notification = PopupNotifications.panel.firstElementChild;
+      checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(checkbox.hidden, "checkbox is not visible");
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      await checkNotSharing();
+
+      // Make sure we are not changing the scope and state of persistent
+      // permission
+      let { state, scope } = SitePermissions.getForPrincipal(
+        principal,
+        "camera",
+        browser
+      );
+      Assert.equal(state, SitePermissions.ALLOW);
+      Assert.equal(scope, SitePermissions.SCOPE_PERSISTENT);
+
+      ({ state, scope } = SitePermissions.getForPrincipal(
+        principal,
+        "microphone",
+        browser
+      ));
+      Assert.equal(state, SitePermissions.ALLOW);
+      Assert.equal(scope, SitePermissions.SCOPE_PERSISTENT);
+
+      PermissionTestUtils.remove(uri, "camera");
+      PermissionTestUtils.remove(uri, "microphone");
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["permissions.delegation.enabled", true],
+      ["dom.security.featurePolicy.header.enabled", true],
+      ["dom.security.featurePolicy.webidl.enabled", true],
+    ],
+  });
+
+  await runTests(gTests, {
+    relativeURI: "get_user_media_in_xorigin_frame.html",
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame_chain.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame_chain.js
new file mode 100644
index 0000000000..ad398994f0
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_in_xorigin_frame_chain.js
@@ -0,0 +1,251 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const PromptResult = {
+  ALLOW: "allow",
+  DENY: "deny",
+  PROMPT: "prompt",
+};
+
+const Perms = Services.perms;
+
+function expectObserverCalledAncestor(aTopic, browsingContext) {
+  if (!gMultiProcessBrowser) {
+    return expectObserverCalledInProcess(aTopic);
+  }
+
+  return BrowserTestUtils.contentTopicObserved(browsingContext, aTopic);
+}
+
+function enableObserverVerificationAncestor(browsingContext) {
+  // Skip these checks in single process mode as it isn't worth implementing it.
+  if (!gMultiProcessBrowser) {
+    return Promise.resolve();
+  }
+
+  return BrowserTestUtils.startObservingTopics(browsingContext, observerTopics);
+}
+
+function disableObserverVerificationAncestor(browsingContextt) {
+  if (!gMultiProcessBrowser) {
+    return Promise.resolve();
+  }
+
+  return BrowserTestUtils.stopObservingTopics(
+    browsingContextt,
+    observerTopics
+  ).catch(reason => {
+    ok(false, "Failed " + reason);
+  });
+}
+
+function promiseRequestDeviceAncestor(
+  aRequestAudio,
+  aRequestVideo,
+  aType,
+  aBrowser,
+  aBadDevice = false
+) {
+  info("requesting devices");
+  return SpecialPowers.spawn(
+    aBrowser,
+    [{ aRequestAudio, aRequestVideo, aType, aBadDevice }],
+    async function (args) {
+      let global =
+        content.wrappedJSObject.document.getElementById("frame4").contentWindow;
+      global.requestDevice(
+        args.aRequestAudio,
+        args.aRequestVideo,
+        args.aType,
+        args.aBadDevice
+      );
+    }
+  );
+}
+
+async function closeStreamAncestor(browser) {
+  let observerPromises = [];
+  observerPromises.push(
+    expectObserverCalledAncestor("recording-device-events", browser)
+  );
+  observerPromises.push(
+    expectObserverCalledAncestor("recording-window-ended", browser)
+  );
+
+  info("closing the stream");
+  await SpecialPowers.spawn(browser, [], async () => {
+    let global =
+      content.wrappedJSObject.document.getElementById("frame4").contentWindow;
+    global.closeStream();
+  });
+
+  await Promise.all(observerPromises);
+
+  await assertWebRTCIndicatorStatus(null);
+}
+
+var gTests = [
+  {
+    desc: "getUserMedia use persistent permissions from first party if third party is explicitly trusted",
+    skipObserverVerification: true,
+    run: async function checkPermissionsAncestorChain() {
+      async function checkPermission(aPermission, aRequestType, aExpect) {
+        info(
+          `Test persistent permission ${aPermission} type ${aRequestType} expect ${aExpect}`
+        );
+        const uri = gBrowser.selectedBrowser.documentURI;
+        // Persistent allow/deny for first party uri
+        PermissionTestUtils.add(uri, aRequestType, aPermission);
+
+        let audio = aRequestType == "microphone";
+        let video = aRequestType == "camera";
+        const screen = aRequestType == "screen" ? "screen" : undefined;
+        if (screen) {
+          audio = false;
+          video = true;
+        }
+        const iframeAncestor = await SpecialPowers.spawn(
+          gBrowser.selectedBrowser,
+          [],
+          () => {
+            return content.document.getElementById("frameAncestor")
+              .browsingContext;
+          }
+        );
+
+        if (aExpect == PromptResult.PROMPT) {
+          // Check that we get a prompt.
+          const observerPromise = expectObserverCalledAncestor(
+            "getUserMedia:request",
+            iframeAncestor
+          );
+          const promise = promisePopupNotificationShown("webRTC-shareDevices");
+
+          await promiseRequestDeviceAncestor(
+            audio,
+            video,
+            screen,
+            iframeAncestor
+          );
+          await promise;
+          await observerPromise;
+
+          // Check the label of the notification should be the first party
+          is(
+            PopupNotifications.getNotification("webRTC-shareDevices").options
+              .name,
+            uri.host,
+            "Use first party's origin"
+          );
+          const observerPromise1 = expectObserverCalledAncestor(
+            "getUserMedia:response:deny",
+            iframeAncestor
+          );
+          const observerPromise2 = expectObserverCalledAncestor(
+            "recording-window-ended",
+            iframeAncestor
+          );
+          // Deny the request to cleanup...
+          activateSecondaryAction(kActionDeny);
+          await observerPromise1;
+          await observerPromise2;
+          let browser = gBrowser.selectedBrowser;
+          SitePermissions.removeFromPrincipal(null, aRequestType, browser);
+        } else if (aExpect == PromptResult.ALLOW) {
+          const observerPromise = expectObserverCalledAncestor(
+            "getUserMedia:request",
+            iframeAncestor
+          );
+          const observerPromise1 = expectObserverCalledAncestor(
+            "getUserMedia:response:allow",
+            iframeAncestor
+          );
+          const observerPromise2 = expectObserverCalledAncestor(
+            "recording-device-events",
+            iframeAncestor
+          );
+          await promiseRequestDeviceAncestor(
+            audio,
+            video,
+            screen,
+            iframeAncestor
+          );
+          await observerPromise;
+
+          await promiseNoPopupNotification("webRTC-shareDevices");
+          await observerPromise1;
+          await observerPromise2;
+
+          let expected = {};
+          if (audio) {
+            expected.audio = audio;
+          }
+          if (video) {
+            expected.video = video;
+          }
+
+          Assert.deepEqual(
+            await getMediaCaptureState(),
+            expected,
+            "expected " + Object.keys(expected).join(" and ") + " to be shared"
+          );
+
+          await closeStreamAncestor(iframeAncestor);
+        } else if (aExpect == PromptResult.DENY) {
+          const observerPromise = expectObserverCalledAncestor(
+            "recording-window-ended",
+            iframeAncestor
+          );
+          await promiseRequestDeviceAncestor(
+            audio,
+            video,
+            screen,
+            iframeAncestor
+          );
+          await observerPromise;
+        }
+
+        PermissionTestUtils.remove(uri, aRequestType);
+      }
+
+      await checkPermission(Perms.PROMPT_ACTION, "camera", PromptResult.PROMPT);
+      await checkPermission(Perms.DENY_ACTION, "camera", PromptResult.DENY);
+      await checkPermission(Perms.ALLOW_ACTION, "camera", PromptResult.ALLOW);
+
+      await checkPermission(
+        Perms.PROMPT_ACTION,
+        "microphone",
+        PromptResult.PROMPT
+      );
+      await checkPermission(Perms.DENY_ACTION, "microphone", PromptResult.DENY);
+      await checkPermission(
+        Perms.ALLOW_ACTION,
+        "microphone",
+        PromptResult.ALLOW
+      );
+
+      await checkPermission(Perms.PROMPT_ACTION, "screen", PromptResult.PROMPT);
+      await checkPermission(Perms.DENY_ACTION, "screen", PromptResult.DENY);
+      // Always prompt screen sharing
+      await checkPermission(Perms.ALLOW_ACTION, "screen", PromptResult.PROMPT);
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["permissions.delegation.enabled", true],
+      ["dom.security.featurePolicy.header.enabled", true],
+      ["dom.security.featurePolicy.webidl.enabled", true],
+    ],
+  });
+
+  await runTests(gTests, {
+    relativeURI: "get_user_media_in_xorigin_frame_ancestor.html",
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_multi_process.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_multi_process.js
new file mode 100644
index 0000000000..fa88b5d030
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_multi_process.js
@@ -0,0 +1,517 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var gTests = [
+  {
+    desc: "getUserMedia audio in a first process + video in a second process",
+    // These tests call enableObserverVerification manually on a second tab, so
+    // don't add listeners to the first tab.
+    skipObserverVerification: true,
+    run: async function checkMultiProcess() {
+      // The main purpose of this test is to ensure webrtc sharing indicators
+      // work with multiple content processes, but it makes sense to run this
+      // test without e10s too to ensure using webrtc devices in two different
+      // tabs is handled correctly.
+
+      // Request audio in the first tab.
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true);
+      await promise;
+      await observerPromise;
+
+      checkDeviceSelectors(["microphone"]);
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      let indicator = promiseIndicatorWindow();
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        !webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator hidden"
+      );
+      ok(
+        webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator shown"
+      );
+      is(
+        webrtcUI.getActiveStreams(false, true).length,
+        1,
+        "1 active audio stream"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        1,
+        "1 active stream"
+      );
+
+      // If we have reached the max process count already, increase it to ensure
+      // our new tab can have its own content process.
+      let childCount = Services.ppmm.childCount;
+      let maxContentProcess = Services.prefs.getIntPref("dom.ipc.processCount");
+      // The first check is because if we are on a branch where e10s-multi is
+      // disabled, we want to keep testing e10s with a single content process.
+      // The + 1 is because ppmm.childCount also counts the chrome process
+      // (which also runs process scripts).
+      if (maxContentProcess > 1 && childCount == maxContentProcess + 1) {
+        await SpecialPowers.pushPrefEnv({
+          set: [["dom.ipc.processCount", childCount]],
+        });
+      }
+
+      // Open a new tab with a different hostname.
+      let url = gBrowser.currentURI.spec.replace(
+        "https://example.com/",
+        "http://127.0.0.1:8888/"
+      );
+      let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
+
+      await enableObserverVerification();
+
+      // Request video.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+
+      checkDeviceSelectors(["camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkSharingUI({ video: true }, window, {
+        audio: true,
+        video: true,
+      });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator shown"
+      );
+      ok(
+        webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator shown"
+      );
+      is(
+        webrtcUI.getActiveStreams(false, true).length,
+        1,
+        "1 active audio stream"
+      );
+      is(webrtcUI.getActiveStreams(true).length, 1, "1 active video stream");
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        2,
+        "2 active streams"
+      );
+
+      info("removing the second tab");
+
+      await disableObserverVerification();
+
+      BrowserTestUtils.removeTab(tab);
+
+      // Check that we still show the sharing indicators for the first tab's stream.
+      await Promise.all([
+        TestUtils.waitForCondition(() => !webrtcUI.showCameraIndicator),
+        TestUtils.waitForCondition(
+          () => webrtcUI.getActiveStreams(true, true, true).length == 1
+        ),
+      ]);
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        !webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator hidden"
+      );
+      ok(
+        webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator shown"
+      );
+      is(
+        webrtcUI.getActiveStreams(false, true).length,
+        1,
+        "1 active audio stream"
+      );
+
+      await checkSharingUI({ audio: true });
+
+      // Close the first tab's stream and verify that all indicators are removed.
+      await closeStream(false, null, true);
+
+      ok(
+        !webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        0,
+        "0 active streams"
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia camera in a first process + camera in a second process",
+    skipObserverVerification: true,
+    run: async function checkMultiProcessCamera() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      // Request camera in the first tab.
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator shown"
+      );
+      ok(
+        !webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator hidden"
+      );
+      is(webrtcUI.getActiveStreams(true).length, 1, "1 active camera stream");
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        1,
+        "1 active stream"
+      );
+
+      // If we have reached the max process count already, increase it to ensure
+      // our new tab can have its own content process.
+      let childCount = Services.ppmm.childCount;
+      let maxContentProcess = Services.prefs.getIntPref("dom.ipc.processCount");
+      // The first check is because if we are on a branch where e10s-multi is
+      // disabled, we want to keep testing e10s with a single content process.
+      // The + 1 is because ppmm.childCount also counts the chrome process
+      // (which also runs process scripts).
+      if (maxContentProcess > 1 && childCount == maxContentProcess + 1) {
+        await SpecialPowers.pushPrefEnv({
+          set: [["dom.ipc.processCount", childCount]],
+        });
+      }
+
+      // Open a new tab with a different hostname.
+      let url = gBrowser.currentURI.spec.replace(
+        "https://example.com/",
+        "http://127.0.0.1:8888/"
+      );
+      let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
+
+      await enableObserverVerification();
+
+      // Request camera in the second tab.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+
+      checkDeviceSelectors(["camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkSharingUI({ video: true }, window, { video: true });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator shown"
+      );
+      ok(
+        !webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator hidden"
+      );
+      is(webrtcUI.getActiveStreams(true).length, 2, "2 active camera streams");
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        2,
+        "2 active streams"
+      );
+
+      await disableObserverVerification();
+
+      info("removing the second tab");
+      BrowserTestUtils.removeTab(tab);
+
+      // Check that we still show the sharing indicators for the first tab's stream.
+      await Promise.all([
+        TestUtils.waitForCondition(() => webrtcUI.showCameraIndicator),
+        TestUtils.waitForCondition(
+          () => webrtcUI.getActiveStreams(true).length == 1
+        ),
+      ]);
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator shown"
+      );
+      ok(
+        !webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        1,
+        "1 active stream"
+      );
+
+      await checkSharingUI({ video: true });
+
+      // Close the first tab's stream and verify that all indicators are removed.
+      await closeStream(false, null, true);
+
+      ok(
+        !webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        0,
+        "0 active streams"
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia screen sharing in a first process + screen sharing in a second process",
+    skipObserverVerification: true,
+    run: async function checkMultiProcessScreen() {
+      // Request screen sharing in the first tab.
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      // Select the last screen so that we can have a stream.
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showScreenSharingIndicator,
+        "webrtcUI wants the screen sharing indicator shown"
+      );
+      ok(
+        !webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator hidden"
+      );
+      ok(
+        !webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(false, false, true).length,
+        1,
+        "1 active screen sharing stream"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        1,
+        "1 active stream"
+      );
+
+      // If we have reached the max process count already, increase it to ensure
+      // our new tab can have its own content process.
+      let childCount = Services.ppmm.childCount;
+      let maxContentProcess = Services.prefs.getIntPref("dom.ipc.processCount");
+      // The first check is because if we are on a branch where e10s-multi is
+      // disabled, we want to keep testing e10s with a single content process.
+      // The + 1 is because ppmm.childCount also counts the chrome process
+      // (which also runs process scripts).
+      if (maxContentProcess > 1 && childCount == maxContentProcess + 1) {
+        await SpecialPowers.pushPrefEnv({
+          set: [["dom.ipc.processCount", childCount]],
+        });
+      }
+
+      // Open a new tab with a different hostname.
+      let url = gBrowser.currentURI.spec.replace(
+        "https://example.com/",
+        "https://example.com/"
+      );
+      let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
+
+      await enableObserverVerification();
+
+      // Request screen sharing in the second tab.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      // Select the last screen so that we can have a stream.
+      menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkSharingUI({ screen: "Screen" }, window, { screen: "Screen" });
+
+      ok(
+        webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator shown"
+      );
+      ok(
+        webrtcUI.showScreenSharingIndicator,
+        "webrtcUI wants the screen sharing indicator shown"
+      );
+      ok(
+        !webrtcUI.showCameraIndicator,
+        "webrtcUI wants the camera indicator hidden"
+      );
+      ok(
+        !webrtcUI.showMicrophoneIndicator,
+        "webrtcUI wants the mic indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(false, false, true).length,
+        2,
+        "2 active desktop sharing streams"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        2,
+        "2 active streams"
+      );
+
+      await disableObserverVerification();
+
+      info("removing the second tab");
+      BrowserTestUtils.removeTab(tab);
+
+      await TestUtils.waitForCondition(
+        () => webrtcUI.getActiveStreams(true, true, true).length == 1
+      );
+
+      // Close the first tab's stream and verify that all indicators are removed.
+      await closeStream(false, null, true);
+
+      ok(
+        !webrtcUI.showGlobalIndicator,
+        "webrtcUI wants the global indicator hidden"
+      );
+      is(
+        webrtcUI.getActiveStreams(true, true, true).length,
+        0,
+        "0 active streams"
+      );
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_paused.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_paused.js
new file mode 100644
index 0000000000..27271c2a45
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_paused.js
@@ -0,0 +1,999 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function setCameraMuted(mute) {
+  return sendObserverNotification(
+    mute ? "getUserMedia:muteVideo" : "getUserMedia:unmuteVideo"
+  );
+}
+
+function setMicrophoneMuted(mute) {
+  return sendObserverNotification(
+    mute ? "getUserMedia:muteAudio" : "getUserMedia:unmuteAudio"
+  );
+}
+
+function sendObserverNotification(topic) {
+  const windowId = gBrowser.selectedBrowser.innerWindowID;
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [{ topic, windowId }],
+    function (args) {
+      Services.obs.notifyObservers(
+        content.window,
+        args.topic,
+        JSON.stringify(args.windowId)
+      );
+    }
+  );
+}
+
+function setTrackEnabled(audio, video) {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [{ audio, video }],
+    function (args) {
+      let stream = content.wrappedJSObject.gStreams[0];
+      if (args.audio != null) {
+        stream.getAudioTracks()[0].enabled = args.audio;
+      }
+      if (args.video != null) {
+        stream.getVideoTracks()[0].enabled = args.video;
+      }
+    }
+  );
+}
+
+async function getVideoTrackMuted() {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [],
+    () => content.wrappedJSObject.gStreams[0].getVideoTracks()[0].muted
+  );
+}
+
+async function getVideoTrackEvents() {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [],
+    () => content.wrappedJSObject.gVideoEvents
+  );
+}
+
+async function getAudioTrackMuted() {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [],
+    () => content.wrappedJSObject.gStreams[0].getAudioTracks()[0].muted
+  );
+}
+
+async function getAudioTrackEvents() {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [],
+    () => content.wrappedJSObject.gAudioEvents
+  );
+}
+
+function cloneTracks(audio, video) {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [{ audio, video }],
+    function (args) {
+      if (!content.wrappedJSObject.gClones) {
+        content.wrappedJSObject.gClones = [];
+      }
+      let clones = content.wrappedJSObject.gClones;
+      let stream = content.wrappedJSObject.gStreams[0];
+      if (args.audio != null) {
+        clones.push(stream.getAudioTracks()[0].clone());
+      }
+      if (args.video != null) {
+        clones.push(stream.getVideoTracks()[0].clone());
+      }
+    }
+  );
+}
+
+function stopClonedTracks(audio, video) {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [{ audio, video }],
+    function (args) {
+      let clones = content.wrappedJSObject.gClones || [];
+      if (args.audio != null) {
+        clones.filter(t => t.kind == "audio").forEach(t => t.stop());
+      }
+      if (args.video != null) {
+        clones.filter(t => t.kind == "video").forEach(t => t.stop());
+      }
+      let liveClones = clones.filter(t => t.readyState == "live");
+      if (!liveClones.length) {
+        delete content.wrappedJSObject.gClones;
+      } else {
+        content.wrappedJSObject.gClones = liveClones;
+      }
+    }
+  );
+}
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+video: disabling the stream shows the paused indicator",
+    run: async function checkDisabled() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // Disable both audio and video.
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setTrackEnabled(false, false);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_DISABLED,
+        "video should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+
+      // Enable only audio again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only video as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // Enable video again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: disabling the original tracks and stopping enabled clones shows the paused indicator",
+    run: async function checkDisabledAfterCloneStop() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // Clone audio and video, their state will be enabled
+      await cloneTracks(true, true);
+
+      // Disable both audio and video.
+      await setTrackEnabled(false, false);
+
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+
+      // Stop the clones. This should disable the sharing indicators.
+      await stopClonedTracks(true, true);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+            STATE_CAPTURE_DISABLED &&
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+            STATE_CAPTURE_DISABLED,
+        "video and audio should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+
+      // Enable only audio again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only video as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // Enable video again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia screen: disabling the stream shows the paused indicator",
+    run: async function checkScreenDisabled() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, false);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.screen == "ScreenPaused",
+        "screen should be disabled"
+      );
+      await observerPromise;
+      await checkSharingUI({ screen: "ScreenPaused" }, window, {
+        screen: "Screen",
+      });
+
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () => window.gPermissionPanel._sharingState.webRTC.screen == "Screen",
+        "screen should be enabled"
+      );
+      await observerPromise;
+      await checkSharingUI({ screen: "Screen" });
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: muting the camera shows the muted indicator",
+    run: async function checkCameraMuted() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track starts unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        [],
+        "no video track events fired yet"
+      );
+
+      // Mute camera.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setCameraMuted(true);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_DISABLED,
+        "video should be muted"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only camera as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), true, "video track is muted");
+      Assert.deepEqual(await getVideoTrackEvents(), ["mute"], "mute fired");
+
+      // Unmute video again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setCameraMuted(false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track is unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute", "unmute"],
+        "unmute fired"
+      );
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: muting the microphone shows the muted indicator",
+    run: async function checkMicrophoneMuted() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track starts unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        [],
+        "no audio track events fired yet"
+      );
+
+      // Mute microphone.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setMicrophoneMuted(true);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_DISABLED,
+        "audio should be muted"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only microphone as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), true, "audio track is muted");
+      Assert.deepEqual(await getAudioTrackEvents(), ["mute"], "mute fired");
+
+      // Unmute audio again.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setMicrophoneMuted(false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track is unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute", "unmute"],
+        "unmute fired"
+      );
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: disabling & muting camera in combination",
+    // Test the following combinations of disabling and muting camera:
+    // 1. Disable video track only.
+    // 2. Mute camera & disable audio (to have a condition to wait for)
+    // 3. Enable both audio and video tracks (only audio should flow).
+    // 4. Unmute camera again (video should flow).
+    // 5. Mute camera & disable both tracks.
+    // 6. Unmute camera & enable audio (only audio should flow)
+    // 7. Enable video track again (video should flow).
+    run: async function checkDisabledMutedCombination() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // 1. Disable video track only.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, false);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_DISABLED,
+        "video should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only video as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track still unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        [],
+        "no video track events fired yet"
+      );
+
+      // 2. Mute camera & disable audio (to have a condition to wait for)
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setCameraMuted(true);
+      await setTrackEnabled(false, null);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_DISABLED,
+        "audio should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getVideoTrackMuted(), true, "video track is muted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute"],
+        "mute is still fired even though track was disabled"
+      );
+
+      // 3. Enable both audio and video tracks (only audio should flow).
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setTrackEnabled(true, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only audio as enabled, as video is muted.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), true, "video track is still muted");
+      Assert.deepEqual(await getVideoTrackEvents(), ["mute"], "no new events");
+
+      // 4. Unmute camera again (video should flow).
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setCameraMuted(false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track is unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute", "unmute"],
+        "unmute fired"
+      );
+
+      // 5. Mute camera & disable both tracks.
+      observerPromise = expectObserverCalled("recording-device-events", 3);
+      await setCameraMuted(true);
+      await setTrackEnabled(false, false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_DISABLED,
+        "video should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getVideoTrackMuted(), true, "video track is muted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute", "unmute", "mute"],
+        "mute fired afain"
+      );
+
+      // 6. Unmute camera & enable audio (only audio should flow)
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setCameraMuted(false);
+      await setTrackEnabled(true, null);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // Only audio should show as running, as video track is still disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track is unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute", "unmute", "mute", "unmute"],
+        "unmute fired even though track is disabled"
+      );
+
+      // 7. Enable video track again (video should flow).
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(null, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as running again.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getVideoTrackMuted(), false, "video track remains unmuted");
+      Assert.deepEqual(
+        await getVideoTrackEvents(),
+        ["mute", "unmute", "mute", "unmute"],
+        "no new events fired"
+      );
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+video: disabling & muting microphone in combination",
+    // Test the following combinations of disabling and muting microphone:
+    // 1. Disable audio track only.
+    // 2. Mute microphone & disable video (to have a condition to wait for)
+    // 3. Enable both audio and video tracks (only video should flow).
+    // 4. Unmute microphone again (audio should flow).
+    // 5. Mute microphone & disable both tracks.
+    // 6. Unmute microphone & enable video (only video should flow)
+    // 7. Enable audio track again (audio should flow).
+    run: async function checkDisabledMutedCombination() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+
+      // 1. Disable audio track only.
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(false, null);
+
+      // Wait for capture state to propagate to the UI asynchronously.
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_DISABLED,
+        "audio should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only audio as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track still unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        [],
+        "no audio track events fired yet"
+      );
+
+      // 2. Mute microphone & disable video (to have a condition to wait for)
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setMicrophoneMuted(true);
+      await setTrackEnabled(null, false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_DISABLED,
+        "camera should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), true, "audio track is muted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute"],
+        "mute is still fired even though track was disabled"
+      );
+
+      // 3. Enable both audio and video tracks (only video should flow).
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setTrackEnabled(true, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show only video as enabled, as audio is muted.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), true, "audio track is still muted");
+      Assert.deepEqual(await getAudioTrackEvents(), ["mute"], "no new events");
+
+      // 4. Unmute microphone again (audio should flow).
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setMicrophoneMuted(false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // Both streams should show as running.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track is unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute", "unmute"],
+        "unmute fired"
+      );
+
+      // 5. Mute microphone & disable both tracks.
+      observerPromise = expectObserverCalled("recording-device-events", 3);
+      await setMicrophoneMuted(true);
+      await setTrackEnabled(false, false);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_DISABLED,
+        "audio should be disabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_DISABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), true, "audio track is muted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute", "unmute", "mute"],
+        "mute fired again"
+      );
+
+      // 6. Unmute microphone & enable video (only video should flow)
+      observerPromise = expectObserverCalled("recording-device-events", 2);
+      await setMicrophoneMuted(false);
+      await setTrackEnabled(null, true);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.camera ==
+          STATE_CAPTURE_ENABLED,
+        "video should be enabled"
+      );
+
+      await observerPromise;
+
+      // Only video should show as running, as audio track is still disabled.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_DISABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track is unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute", "unmute", "mute", "unmute"],
+        "unmute fired even though track is disabled"
+      );
+
+      // 7. Enable audio track again (audio should flow).
+      observerPromise = expectObserverCalled("recording-device-events");
+      await setTrackEnabled(true, null);
+
+      await BrowserTestUtils.waitForCondition(
+        () =>
+          window.gPermissionPanel._sharingState.webRTC.microphone ==
+          STATE_CAPTURE_ENABLED,
+        "audio should be enabled"
+      );
+
+      await observerPromise;
+
+      // The identity UI should show both as running again.
+      await checkSharingUI({
+        video: STATE_CAPTURE_ENABLED,
+        audio: STATE_CAPTURE_ENABLED,
+      });
+      is(await getAudioTrackMuted(), false, "audio track remains unmuted");
+      Assert.deepEqual(
+        await getAudioTrackEvents(),
+        ["mute", "unmute", "mute", "unmute"],
+        "no new events fired"
+      );
+      await closeStream();
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["media.getusermedia.camera.off_while_disabled.delay_ms", 0],
+      ["media.getusermedia.microphone.off_while_disabled.delay_ms", 0],
+    ],
+  });
+
+  SimpleTest.requestCompleteLog();
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_queue_request.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_queue_request.js
new file mode 100644
index 0000000000..1c90787640
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_queue_request.js
@@ -0,0 +1,383 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const badDeviceError =
+  "error: NotReadableError: Failed to allocate videosource";
+
+var gTests = [
+  {
+    desc: "test 'Not now' label queueing audio twice behind allow video",
+    run: async function testQueuingDenyAudioBehindAllowVideo() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promiseRequestDevice(true, false);
+      await promiseRequestDevice(true, false);
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      checkDeviceSelectors(["camera"]);
+      await observerPromise;
+      let indicator = promiseIndicatorWindow();
+
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Block",
+          "We offer Block because of no active camera/mic device"
+        );
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: false, video: true });
+
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await observerPromise;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      checkDeviceSelectors(["microphone"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Not now",
+          "We offer Not now option because of an allowed camera/mic device"
+        );
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Not now",
+          "We offer Not now option again because of an allowed camera/mic device"
+        );
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+
+      // Clean up the active camera in the activePerms map
+      webrtcUI.activePerms.delete(gBrowser.selectedBrowser.outerWindowID);
+
+      // close all streams
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "test 'Not now'/'Block' label queueing microphone behind screen behind allow camera",
+    run: async function testQueuingAudioAndScreenBehindAllowVideo() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promiseRequestDevice(false, true, null, "screen");
+      await promiseRequestDevice(true, false);
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      checkDeviceSelectors(["camera"]);
+      await observerPromise;
+
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Block",
+          "We offer Block because of no active camera/mic device"
+        );
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+      await checkSharingUI({ audio: false, video: true });
+
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await observerPromise;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      checkDeviceSelectors(["screen"]);
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Not now",
+          "We offer Not now option because we are asking for screen"
+        );
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise;
+
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        is(
+          PopupNotifications.panel.firstElementChild.secondaryButton.label,
+          "Not now",
+          "We offer Not now option because we are asking for mic and cam is already active"
+        );
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise;
+
+      // Clean up
+      webrtcUI.activePerms.delete(gBrowser.selectedBrowser.outerWindowID);
+      // close all streams
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "test queueing allow video behind deny audio",
+    run: async function testQueuingAllowVideoBehindDenyAudio() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promiseRequestDevice(false, true);
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+      ];
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await Promise.all(observerPromises);
+      checkDeviceSelectors(["camera"]);
+
+      let indicator = promiseIndicatorWindow();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: false, video: true });
+
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // close all streams
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "test queueing allow audio behind allow video with error",
+    run: async function testQueuingAllowAudioBehindAllowVideoWithError() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(
+        false,
+        true,
+        null,
+        null,
+        gBrowser.selectedBrowser,
+        true
+      );
+      await promiseRequestDevice(true, false);
+      await observerPromise;
+      await promise;
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+
+      checkDeviceSelectors(["camera"]);
+
+      let observerPromise1 = expectObserverCalled("getUserMedia:request");
+      let observerPromise2 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      await promiseMessage(badDeviceError, () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      await promise;
+      checkDeviceSelectors(["microphone"]);
+
+      let indicator = promiseIndicatorWindow();
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: true, video: false });
+
+      // Clean up the active microphone in the activePerms map
+      webrtcUI.activePerms.delete(gBrowser.selectedBrowser.outerWindowID);
+
+      // close all streams
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "test queueing audio+video behind deny audio",
+    run: async function testQueuingAllowVideoBehindDenyAudio() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny", 2),
+        expectObserverCalled("recording-window-ended"),
+      ];
+
+      await promiseMessage(
+        permissionError,
+        () => {
+          activateSecondaryAction(kActionDeny);
+        },
+        2
+      );
+      await Promise.all(observerPromises);
+
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "test queueing audio, video behind reload after pending audio, video",
+    run: async function testQueuingDenyAudioBehindAllowVideo() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      await reloadAndAssertClosedStreams();
+
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      // After the reload, gUM(audio) causes a prompt.
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      // expect pending camera prompt to appear after ok'ing microphone one.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ video: false, audio: true });
+
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+      observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected microphone and camera to be shared"
+      );
+
+      // close all streams
+      await closeStream();
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_screen.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_screen.js
new file mode 100644
index 0000000000..d09d7f2c5f
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_screen.js
@@ -0,0 +1,949 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// The rejection "The fetching process for the media resource was aborted by the
+// user agent at the user's request." is left unhandled in some cases. This bug
+// should be fixed, but for the moment this file allows a class of rejections.
+//
+// NOTE: Allowing a whole class of rejections should be avoided. Normally you
+//       should use "expectUncaughtRejection" to flag individual failures.
+const { PromiseTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PromiseTestUtils.sys.mjs"
+);
+PromiseTestUtils.allowMatchingRejectionsGlobally(/aborted by the user agent/);
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+const notFoundError = "error: NotFoundError: The object can not be found here.";
+
+const isHeadless = Services.env.get("MOZ_HEADLESS");
+
+function verifyTabSharingPopup(expectedItems) {
+  let event = new MouseEvent("popupshowing");
+  let sharingMenu = document.getElementById("tabSharingMenuPopup");
+  sharingMenu.dispatchEvent(event);
+
+  is(
+    sharingMenu.children.length,
+    expectedItems.length,
+    "correct number of items on tab sharing menu"
+  );
+  for (let i = 0; i < expectedItems.length; i++) {
+    is(
+      JSON.parse(sharingMenu.children[i].getAttribute("data-l10n-args"))
+        .itemList,
+      expectedItems[i],
+      "label of item " + i + " + was correct"
+    );
+  }
+
+  sharingMenu.dispatchEvent(new MouseEvent("popuphiding"));
+}
+
+var gTests = [
+  {
+    desc: "getUserMedia window/screen picking screen",
+    run: async function checkWindowOrScreen() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+      let notification = PopupNotifications.panel.firstElementChild;
+
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      let count = menulist.itemCount;
+      ok(
+        count >= 4,
+        "There should be the 'Select Window or Screen' item, a separator and at least one window and one screen"
+      );
+
+      let noWindowOrScreenItem = menulist.getItemAtIndex(0);
+      ok(
+        noWindowOrScreenItem.hasAttribute("selected"),
+        "the 'Select Window or Screen' item is selected"
+      );
+      is(
+        menulist.selectedItem,
+        noWindowOrScreenItem,
+        "'Select Window or Screen' is the selected item"
+      );
+      is(menulist.value, "-1", "no window or screen is selected by default");
+      ok(
+        noWindowOrScreenItem.disabled,
+        "'Select Window or Screen' item is disabled"
+      );
+      ok(notification.button.disabled, "Allow button is disabled");
+      ok(
+        notification.hasAttribute("invalidselection"),
+        "Notification is marked as invalid"
+      );
+
+      let separator = menulist.getItemAtIndex(1);
+      is(
+        separator.localName,
+        "menuseparator",
+        "the second item is a separator"
+      );
+
+      ok(
+        document.getElementById("webRTC-all-windows-shared").hidden,
+        "the 'all windows will be shared' warning should be hidden while there's no selection"
+      );
+      ok(
+        document.getElementById("webRTC-preview").hidden,
+        "the preview area is hidden"
+      );
+
+      let scaryScreenIndex;
+      for (let i = 2; i < count; ++i) {
+        let item = menulist.getItemAtIndex(i);
+        is(
+          parseInt(item.getAttribute("value")),
+          i - 2,
+          "the window/screen item has the correct index"
+        );
+        let type = item.getAttribute("devicetype");
+        ok(
+          ["window", "screen"].includes(type),
+          "the devicetype attribute is set correctly"
+        );
+        if (type == "screen") {
+          ok(item.scary, "the screen item is marked as scary");
+          scaryScreenIndex = i;
+        }
+      }
+      ok(
+        typeof scaryScreenIndex == "number",
+        "there's at least one scary screen, as as all screens are"
+      );
+
+      // Select a screen, a preview with a scary warning should appear.
+      menulist.getItemAtIndex(scaryScreenIndex).doCommand();
+      ok(
+        !document.getElementById("webRTC-all-windows-shared").hidden,
+        "the 'all windows will be shared' warning should now be visible"
+      );
+      await TestUtils.waitForCondition(
+        () => !document.getElementById("webRTC-preview").hidden,
+        "preview unhide",
+        100,
+        100
+      );
+      ok(
+        !document.getElementById("webRTC-preview").hidden,
+        "the preview area is visible"
+      );
+      ok(
+        !document.getElementById("webRTC-previewWarningBox").hidden,
+        "the scary warning is visible"
+      );
+      ok(!notification.button.disabled, "Allow button is enabled");
+
+      // Select the 'Select Window or Screen' item again, the preview should be hidden.
+      menulist.getItemAtIndex(0).doCommand();
+      ok(
+        document.getElementById("webRTC-all-windows-shared").hidden,
+        "the 'all windows will be shared' warning should now be hidden"
+      );
+      ok(
+        document.getElementById("webRTC-preview").hidden,
+        "the preview area is hidden"
+      );
+
+      // Select the scary screen again so that we can have a stream.
+      menulist.getItemAtIndex(scaryScreenIndex).doCommand();
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+      verifyTabSharingPopup(["screen"]);
+
+      // we always show prompt for screen sharing.
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia window/screen picking window",
+    run: async function checkWindowOrScreen() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "window");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+      let notification = PopupNotifications.panel.firstElementChild;
+
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      let count = menulist.itemCount;
+      ok(
+        count >= 4,
+        "There should be the 'Select Window or Screen' item, a separator and at least one window and one screen"
+      );
+
+      let noWindowOrScreenItem = menulist.getItemAtIndex(0);
+      ok(
+        noWindowOrScreenItem.hasAttribute("selected"),
+        "the 'Select Window or Screen' item is selected"
+      );
+      is(
+        menulist.selectedItem,
+        noWindowOrScreenItem,
+        "'Select Window or Screen' is the selected item"
+      );
+      is(menulist.value, "-1", "no window or screen is selected by default");
+      ok(
+        noWindowOrScreenItem.disabled,
+        "'Select Window or Screen' item is disabled"
+      );
+      ok(notification.button.disabled, "Allow button is disabled");
+      ok(
+        notification.hasAttribute("invalidselection"),
+        "Notification is marked as invalid"
+      );
+
+      let separator = menulist.getItemAtIndex(1);
+      is(
+        separator.localName,
+        "menuseparator",
+        "the second item is a separator"
+      );
+
+      ok(
+        document.getElementById("webRTC-all-windows-shared").hidden,
+        "the 'all windows will be shared' warning should be hidden while there's no selection"
+      );
+      ok(
+        document.getElementById("webRTC-preview").hidden,
+        "the preview area is hidden"
+      );
+
+      let scaryWindowIndexes = [],
+        nonScaryWindowIndex,
+        scaryScreenIndex;
+      for (let i = 2; i < count; ++i) {
+        let item = menulist.getItemAtIndex(i);
+        is(
+          parseInt(item.getAttribute("value")),
+          i - 2,
+          "the window/screen item has the correct index"
+        );
+        let type = item.getAttribute("devicetype");
+        ok(
+          ["window", "screen"].includes(type),
+          "the devicetype attribute is set correctly"
+        );
+        if (type == "screen") {
+          ok(item.scary, "the screen item is marked as scary");
+          scaryScreenIndex = i;
+        } else if (item.scary) {
+          scaryWindowIndexes.push(i);
+        } else {
+          nonScaryWindowIndex = i;
+        }
+      }
+      if (isHeadless) {
+        is(
+          scaryWindowIndexes.length,
+          0,
+          "there are no scary Firefox windows in headless mode"
+        );
+      } else {
+        ok(
+          scaryWindowIndexes.length,
+          "there's at least one scary window, as Firefox is running"
+        );
+      }
+      ok(
+        typeof scaryScreenIndex == "number",
+        "there's at least one scary screen, as all screens are"
+      );
+
+      if (!isHeadless) {
+        // Select one scary window, a preview with a scary warning should appear.
+        let scaryWindowIndex;
+        for (scaryWindowIndex of scaryWindowIndexes) {
+          menulist.getItemAtIndex(scaryWindowIndex).doCommand();
+          ok(
+            document.getElementById("webRTC-all-windows-shared").hidden,
+            "the 'all windows will be shared' warning should still be hidden"
+          );
+          try {
+            await TestUtils.waitForCondition(
+              () => !document.getElementById("webRTC-preview").hidden,
+              "",
+              100,
+              100
+            );
+            break;
+          } catch (e) {
+            // A "scary window" is Firefox. Multiple Firefox windows have been
+            // observed to come and go during try runs, so we won't know which one
+            // is ours. To avoid intermittents, we ignore preview failing due to
+            // these going away on us, provided it succeeds on one of them.
+          }
+        }
+        ok(
+          !document.getElementById("webRTC-preview").hidden,
+          "the preview area is visible"
+        );
+        ok(
+          !document.getElementById("webRTC-previewWarningBox").hidden,
+          "the scary warning is visible"
+        );
+        // Select the 'Select Window' item again, the preview should be hidden.
+        menulist.getItemAtIndex(0).doCommand();
+        ok(
+          document.getElementById("webRTC-preview").hidden,
+          "the preview area is hidden"
+        );
+
+        // Select the first window again so that we can have a stream.
+        menulist.getItemAtIndex(scaryWindowIndex).doCommand();
+      }
+
+      let sharingNonScaryWindow = typeof nonScaryWindowIndex == "number";
+
+      // If we have a non-scary window, select it and verify the warning isn't displayed.
+      // A non-scary window may not always exist on test machines.
+      if (sharingNonScaryWindow) {
+        menulist.getItemAtIndex(nonScaryWindowIndex).doCommand();
+        ok(
+          document.getElementById("webRTC-all-windows-shared").hidden,
+          "the 'all windows will be shared' warning should still be hidden"
+        );
+        await TestUtils.waitForCondition(
+          () => !document.getElementById("webRTC-preview").hidden,
+          "preview unhide",
+          100,
+          100
+        );
+        ok(
+          !document.getElementById("webRTC-preview").hidden,
+          "the preview area is visible"
+        );
+        ok(
+          document.getElementById("webRTC-previewWarningBox").hidden,
+          "the scary warning is hidden"
+        );
+      } else {
+        info("no non-scary window available on this test machine");
+      }
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Window" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      if (sharingNonScaryWindow) {
+        await checkSharingUI({ screen: "Window" });
+      } else {
+        await checkSharingUI({ screen: "Window", browserwindow: true });
+      }
+
+      verifyTabSharingPopup(["window"]);
+
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio + window/screen",
+    run: async function checkAudioVideo() {
+      if (AppConstants.platform == "macosx") {
+        todo(
+          false,
+          "Bug 1323481 - On Mac on treeherder, but not locally, requesting microphone + screen never makes the permission prompt appear, and so causes the test to timeout"
+        );
+        return;
+      }
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, null, "window");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["microphone", "screen"]);
+
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      let count = menulist.itemCount;
+      ok(
+        count >= 4,
+        "There should be the 'Select Window or Screen' item, a separator and at least one window and one screen"
+      );
+
+      // Select a screen, a preview with a scary warning should appear.
+      menulist.getItemAtIndex(count - 1).doCommand();
+      ok(
+        !document.getElementById("webRTC-all-windows-shared").hidden,
+        "the 'all windows will be shared' warning should now be visible"
+      );
+      await TestUtils.waitForCondition(
+        () => !document.getElementById("webRTC-preview").hidden,
+        "preview unhide",
+        100,
+        100
+      );
+      ok(
+        !document.getElementById("webRTC-preview").hidden,
+        "the preview area is visible"
+      );
+      ok(
+        !document.getElementById("webRTC-previewWarningBox").hidden,
+        "the scary warning is visible"
+      );
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, screen: "Screen" },
+        "expected screen and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true, screen: "Screen" });
+
+      verifyTabSharingPopup(["microphone and screen"]);
+
+      await closeStream();
+    },
+  },
+
+  {
+    desc: 'getUserMedia screen, user clicks "Don\'t Allow"',
+    run: async function checkDontShare() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["screen"]);
+
+      let observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      let observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      await checkNotSharing();
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio + window/screen: stop sharing",
+    run: async function checkStopSharing() {
+      if (AppConstants.platform == "macosx") {
+        todo(
+          false,
+          "Bug 1323481 - On Mac on treeherder, but not locally, requesting microphone + screen never makes the permission prompt appear, and so causes the test to timeout"
+        );
+        return;
+      }
+
+      async function share(deviceTypes) {
+        let promise = promisePopupNotificationShown("webRTC-shareDevices");
+        let observerPromise = expectObserverCalled("getUserMedia:request");
+        await promiseRequestDevice(
+          /* audio */ deviceTypes.includes("microphone"),
+          /* video */ deviceTypes.some(t => t == "screen" || t == "camera"),
+          null,
+          deviceTypes.includes("screen") && "window"
+        );
+        await promise;
+        await observerPromise;
+        checkDeviceSelectors(deviceTypes);
+        if (screen) {
+          let menulist = document.getElementById(
+            "webRTC-selectWindow-menulist"
+          );
+          menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+        }
+        let observerPromise1 = expectObserverCalled(
+          "getUserMedia:response:allow"
+        );
+        let observerPromise2 = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await observerPromise1;
+        await observerPromise2;
+      }
+
+      async function check(expected = {}, expectedSharingLabel) {
+        let shared = Object.keys(expected).join(" and ");
+        if (shared) {
+          Assert.deepEqual(
+            await getMediaCaptureState(),
+            expected,
+            "expected " + shared + " to be shared"
+          );
+          await checkSharingUI(expected);
+          verifyTabSharingPopup([expectedSharingLabel]);
+        } else {
+          await checkNotSharing();
+          verifyTabSharingPopup([""]);
+        }
+      }
+
+      info("Share screen and microphone");
+      let indicator = promiseIndicatorWindow();
+      await share(["microphone", "screen"]);
+      await indicator;
+      await check({ audio: true, screen: "Screen" }, "microphone and screen");
+
+      info("Share camera");
+      await share(["camera"]);
+      await check(
+        { video: true, audio: true, screen: "Screen" },
+        "microphone, screen, and camera"
+      );
+
+      info("Stop the screen share, mic+cam should continue");
+      await stopSharing("screen", true);
+      await check({ video: true, audio: true }, "microphone and camera");
+
+      info("Stop the camera, everything should stop.");
+      await stopSharing("camera");
+
+      info("Now, share only the screen...");
+      indicator = promiseIndicatorWindow();
+      await share(["screen"]);
+      await indicator;
+      await check({ screen: "Screen" }, "screen");
+
+      info("... and add camera and microphone in a second request.");
+      await share(["microphone", "camera"]);
+      await check(
+        { video: true, audio: true, screen: "Screen" },
+        "screen, microphone, and camera"
+      );
+
+      info("Stop the camera, this should stop everything.");
+      await stopSharing("camera");
+    },
+  },
+
+  {
+    desc: "getUserMedia window/screen: reloading the page removes all gUM UI",
+    run: async function checkReloading() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["screen"]);
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+      verifyTabSharingPopup(["screen"]);
+
+      await reloadAndAssertClosedStreams();
+    },
+  },
+
+  {
+    desc: "test showControlCenter from screen icon",
+    run: async function checkShowControlCenter() {
+      if (!USING_LEGACY_INDICATOR) {
+        info(
+          "Skipping since this test doesn't apply to the new global sharing " +
+            "indicator."
+        );
+        return;
+      }
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["screen"]);
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      let indicator = promiseIndicatorWindow();
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { screen: "Screen" },
+        "expected screen to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ screen: "Screen" });
+      verifyTabSharingPopup(["screen"]);
+
+      ok(permissionPopupHidden(), "control center should be hidden");
+      if (IS_MAC) {
+        let activeStreams = webrtcUI.getActiveStreams(false, false, true);
+        webrtcUI.showSharingDoorhanger(activeStreams[0]);
+      } else {
+        let win = Services.wm.getMostRecentWindow(
+          "Browser:WebRTCGlobalIndicator"
+        );
+        let elt = win.document.getElementById("screenShareButton");
+        EventUtils.synthesizeMouseAtCenter(elt, {}, win);
+      }
+      await TestUtils.waitForCondition(
+        () => !permissionPopupHidden(),
+        "wait for control center to open"
+      );
+      ok(!permissionPopupHidden(), "control center should be open");
+
+      gPermissionPanel._permissionPopup.hidePopup();
+
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "Only persistent block is possible for screen sharing",
+    run: async function checkPersistentPermissions() {
+      // This test doesn't apply when the notification silencing
+      // feature is enabled, since the "Remember this decision"
+      // checkbox doesn't exist.
+      if (ALLOW_SILENCING_NOTIFICATIONS) {
+        return;
+      }
+
+      let browser = gBrowser.selectedBrowser;
+      let devicePerms = SitePermissions.getForPrincipal(
+        browser.contentPrincipal,
+        "screen",
+        browser
+      );
+      is(
+        devicePerms.state,
+        SitePermissions.UNKNOWN,
+        "starting without screen persistent permissions"
+      );
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["screen"]);
+      document
+        .getElementById("webRTC-selectWindow-menulist")
+        .getItemAtIndex(2)
+        .doCommand();
+
+      // Ensure that checking the 'Remember this decision' checkbox disables
+      // 'Allow'.
+      let notification = PopupNotifications.panel.firstElementChild;
+      ok(
+        notification.hasAttribute("warninghidden"),
+        "warning message is hidden"
+      );
+      let checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.checked, "checkbox is not checked");
+      checkbox.click();
+      ok(checkbox.checked, "checkbox now checked");
+      ok(notification.button.disabled, "Allow button is disabled");
+      ok(
+        !notification.hasAttribute("warninghidden"),
+        "warning message is shown"
+      );
+
+      // Click "Don't Allow" to save a persistent block permission.
+      let observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      let observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise1;
+      await observerPromise2;
+      await checkNotSharing();
+
+      let permission = SitePermissions.getForPrincipal(
+        browser.contentPrincipal,
+        "screen",
+        browser
+      );
+      is(permission.state, SitePermissions.BLOCK, "screen sharing is blocked");
+      is(
+        permission.scope,
+        SitePermissions.SCOPE_PERSISTENT,
+        "screen sharing is persistently blocked"
+      );
+
+      // Request screensharing again, expect an immediate failure.
+      await Promise.all([
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:deny"),
+        expectObserverCalled("recording-window-ended"),
+        promiseMessage(permissionError),
+        promiseRequestDevice(false, true, null, "screen"),
+      ]);
+
+      // Now set the permission to allow and expect a prompt.
+      SitePermissions.setForPrincipal(
+        browser.contentPrincipal,
+        "screen",
+        SitePermissions.ALLOW
+      );
+
+      // Request devices and expect a prompt despite the saved 'Allow' permission.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      // The 'remember' checkbox shouldn't be checked anymore.
+      notification = PopupNotifications.panel.firstElementChild;
+      ok(
+        notification.hasAttribute("warninghidden"),
+        "warning message is hidden"
+      );
+      checkbox = notification.checkbox;
+      ok(!!checkbox, "checkbox is present");
+      ok(!checkbox.checked, "checkbox is not checked");
+
+      // Deny the request to cleanup...
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise1;
+      await observerPromise2;
+      SitePermissions.removeFromPrincipal(
+        browser.contentPrincipal,
+        "screen",
+        browser
+      );
+    },
+  },
+
+  {
+    desc: "Switching between menu options maintains correct main action state while window sharing",
+    skipObserverVerification: true,
+    run: async function checkDoorhangerState() {
+      await enableObserverVerification();
+
+      let win = await BrowserTestUtils.openNewBrowserWindow();
+      await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:newtab");
+      BrowserWindowTracker.orderedWindows[1].focus();
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "window");
+      await promise;
+      await observerPromise;
+
+      let menulist = document.getElementById("webRTC-selectWindow-menulist");
+      let notification = PopupNotifications.panel.firstElementChild;
+      let checkbox = notification.checkbox;
+
+      menulist.getItemAtIndex(2).doCommand();
+      checkbox.click();
+      ok(checkbox.checked, "checkbox now checked");
+
+      if (ALLOW_SILENCING_NOTIFICATIONS) {
+        // When the notification silencing feature is enabled, the checkbox
+        // controls that feature, and its state should not disable the
+        // "Allow" button.
+        ok(!notification.button.disabled, "Allow button is not disabled");
+      } else {
+        ok(notification.button.disabled, "Allow button is disabled");
+        ok(
+          !notification.hasAttribute("warninghidden"),
+          "warning message is shown"
+        );
+      }
+
+      menulist.getItemAtIndex(3).doCommand();
+      ok(checkbox.checked, "checkbox still checked");
+      if (ALLOW_SILENCING_NOTIFICATIONS) {
+        // When the notification silencing feature is enabled, the checkbox
+        // controls that feature, and its state should not disable the
+        // "Allow" button.
+        ok(!notification.button.disabled, "Allow button remains not disabled");
+      } else {
+        ok(notification.button.disabled, "Allow button remains disabled");
+        ok(
+          !notification.hasAttribute("warninghidden"),
+          "warning message is still shown"
+        );
+      }
+
+      await disableObserverVerification();
+
+      observerPromise = expectObserverCalled("recording-window-ended");
+
+      gBrowser.removeCurrentTab();
+      win.close();
+
+      await observerPromise;
+
+      await openNewTestTab();
+    },
+  },
+  {
+    desc: "Switching between tabs does not bleed state into other prompts",
+    skipObserverVerification: true,
+    run: async function checkSwitchingTabs() {
+      // Open a new window in the background to have a choice in the menulist.
+      let win = await BrowserTestUtils.openNewBrowserWindow();
+      await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:newtab");
+      await enableObserverVerification();
+      BrowserWindowTracker.orderedWindows[1].focus();
+
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "window");
+      await promise;
+      await observerPromise;
+
+      let notification = PopupNotifications.panel.firstElementChild;
+      ok(notification.button.disabled, "Allow button is disabled");
+      await disableObserverVerification();
+
+      await openNewTestTab("get_user_media_in_xorigin_frame.html");
+      await enableObserverVerification();
+
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+
+      notification = PopupNotifications.panel.firstElementChild;
+      ok(!notification.button.disabled, "Allow button is not disabled");
+
+      await disableObserverVerification();
+
+      gBrowser.removeCurrentTab();
+      gBrowser.removeCurrentTab();
+      win.close();
+
+      await openNewTestTab();
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_screen_tab_close.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_screen_tab_close.js
new file mode 100644
index 0000000000..9b6cd2fd8e
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_screen_tab_close.js
@@ -0,0 +1,73 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+/**
+ * Tests that the given tab is the currently selected tab.
+ * @param {Element} aTab - Tab to test.
+ */
+function testSelected(aTab) {
+  is(aTab, gBrowser.selectedTab, "Tab is gBrowser.selectedTab");
+  is(aTab.getAttribute("selected"), "true", "Tab has property 'selected'");
+  is(
+    aTab.getAttribute("visuallyselected"),
+    "true",
+    "Tab has property 'visuallyselected'"
+  );
+}
+
+/**
+ * Tests that when closing a tab with active screen sharing, the screen sharing
+ * ends and the tab closes properly.
+ */
+add_task(async function testScreenSharingTabClose() {
+  let initialTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "https://example.com"
+  );
+
+  // Open another foreground tab and ensure its selected.
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  testSelected(tab);
+
+  // Start screen sharing in active tab
+  await shareDevices(tab.linkedBrowser, false, false, SHARE_WINDOW);
+  ok(tab._sharingState.webRTC.screen, "Tab has webRTC screen sharing state");
+
+  let recordingEndedPromise = expectObserverCalled(
+    "recording-window-ended",
+    1,
+    tab.linkedBrowser.browsingContext
+  );
+  let tabClosedPromise = BrowserTestUtils.waitForCondition(
+    () => gBrowser.selectedTab == initialTab,
+    "Waiting for tab to close"
+  );
+
+  // Close tab
+  BrowserTestUtils.removeTab(tab, { animate: true });
+
+  // Wait for screen sharing to end
+  await recordingEndedPromise;
+
+  // Wait for tab to be fully closed
+  await tabClosedPromise;
+
+  // Test that we're back to the initial tab.
+  testSelected(initialTab);
+
+  // There should be no active sharing for the selected tab.
+  ok(
+    !gBrowser.selectedTab._sharingState?.webRTC?.screen,
+    "Selected tab doesn't have webRTC screen sharing state"
+  );
+
+  BrowserTestUtils.removeTab(initialTab);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_tear_off_tab.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_tear_off_tab.js
new file mode 100644
index 0000000000..ef69d15971
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_tear_off_tab.js
@@ -0,0 +1,100 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var gTests = [
+  {
+    desc: "getUserMedia: tearing-off a tab keeps sharing indicators",
+    skipObserverVerification: true,
+    run: async function checkTearingOff() {
+      await enableObserverVerification();
+
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // Don't listen to observer notifications in the tab any more, as
+      // they will need to be switched to the new window.
+      await disableObserverVerification();
+
+      info("tearing off the tab");
+      let win = gBrowser.replaceTabWithWindow(gBrowser.selectedTab);
+      await whenDelayedStartupFinished(win);
+      await checkSharingUI({ audio: true, video: true }, win);
+
+      await enableObserverVerification(win.gBrowser.selectedBrowser);
+
+      // Clicking the global sharing indicator should open the control center in
+      // the second window.
+      ok(permissionPopupHidden(win), "control center should be hidden");
+      let activeStreams = webrtcUI.getActiveStreams(true, false, false);
+      webrtcUI.showSharingDoorhanger(activeStreams[0]);
+      // If the popup gets hidden before being shown, by stray focus/activate
+      // events, don't bother failing the test. It's enough to know that we
+      // started showing the popup.
+      let popup = win.gPermissionPanel._permissionPopup;
+      let hiddenEvent = BrowserTestUtils.waitForEvent(popup, "popuphidden");
+      let shownEvent = BrowserTestUtils.waitForEvent(popup, "popupshown");
+      let ev = await Promise.race([hiddenEvent, shownEvent]);
+      ok(ev.type, "Tried to show popup");
+      win.gPermissionPanel._permissionPopup.hidePopup();
+
+      ok(
+        permissionPopupHidden(window),
+        "control center should be hidden in the first window"
+      );
+
+      await disableObserverVerification();
+
+      // Closing the new window should remove all sharing indicators.
+      let promises = [
+        expectObserverCalledOnClose(
+          "recording-device-events",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+        expectObserverCalledOnClose(
+          "recording-window-ended",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+      ];
+
+      await BrowserTestUtils.closeWindow(win);
+      await Promise.all(promises);
+      await checkNotSharing();
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({ set: [["dom.ipc.processCount", 1]] });
+
+  // An empty tab where we can load the content script without leaving it
+  // behind at the end of the test.
+  BrowserTestUtils.addTab(gBrowser);
+
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access.js
new file mode 100644
index 0000000000..e3276cebc4
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access.js
@@ -0,0 +1,666 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+camera",
+    run: async function checkAudioVideoWhileLiveTracksExist_audio_camera() {
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      let indicator = promiseIndicatorWindow();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+
+      // If there's an active audio+camera stream,
+      // gUM(audio+camera) returns a stream without prompting;
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+
+      promise = promiseMessage("ok");
+
+      await promiseRequestDevice(true, true);
+      await promise;
+      await Promise.all(observerPromises);
+
+      await promiseNoPopupNotification("webRTC-shareDevices");
+
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await checkSharingUI({ audio: true, video: true });
+
+      // gUM(screen) causes a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+      await observerPromise;
+
+      // Revoke screen block (only). Don't over-revoke ahead of remaining steps.
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+
+      // After closing all streams, gUM(audio+camera) causes a prompt.
+      await closeStream();
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+
+      await checkNotSharing();
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+camera -camera",
+    run: async function checkAudioVideoWhileLiveTracksExist_audio_nocamera() {
+      // State: fresh
+
+      {
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        const request = expectObserverCalled("getUserMedia:request");
+        await promiseRequestDevice(true, true);
+        await popupShown;
+        await request;
+        const indicator = promiseIndicatorWindow();
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await indicator;
+        await checkSharingUI({ audio: true, video: true });
+
+        // Stop the camera track.
+        await stopTracks("video");
+        await checkSharingUI({ audio: true, video: false });
+      }
+
+      // State: live audio
+
+      {
+        // If there's an active audio track from an audio+camera request,
+        // gUM(camera) causes a prompt.
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(false, true);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["camera"]);
+
+        // Allow and stop the camera again.
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await checkSharingUI({ audio: true, video: true });
+
+        await stopTracks("video");
+        await checkSharingUI({ audio: true, video: false });
+      }
+
+      // State: live audio
+
+      {
+        // If there's an active audio track from an audio+camera request,
+        // gUM(audio+camera) causes a prompt.
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(true, true);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["microphone", "camera"]);
+
+        // Allow and stop the camera again.
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await checkSharingUI({ audio: true, video: true });
+
+        await stopTracks("video");
+        await checkSharingUI({ audio: true, video: false });
+      }
+
+      // State: live audio
+
+      {
+        // After closing all streams, gUM(audio) causes a prompt.
+        await closeStream();
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(true, false);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["microphone"]);
+
+        const response = expectObserverCalled("getUserMedia:response:deny");
+        const windowEnded = expectObserverCalled("recording-window-ended");
+
+        await promiseMessage(permissionError, () => {
+          activateSecondaryAction(kActionDeny);
+        });
+
+        await response;
+        await windowEnded;
+
+        await checkNotSharing();
+        SitePermissions.removeFromPrincipal(
+          null,
+          "camera",
+          gBrowser.selectedBrowser
+        );
+        SitePermissions.removeFromPrincipal(
+          null,
+          "microphone",
+          gBrowser.selectedBrowser
+        );
+      }
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+camera -audio",
+    run: async function checkAudioVideoWhileLiveTracksExist_camera_noaudio() {
+      // State: fresh
+
+      {
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        const request = expectObserverCalled("getUserMedia:request");
+        await promiseRequestDevice(true, true);
+        await popupShown;
+        await request;
+        const indicator = promiseIndicatorWindow();
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await indicator;
+        await checkSharingUI({ audio: true, video: true });
+
+        // Stop the audio track.
+        await stopTracks("audio");
+        await checkSharingUI({ audio: false, video: true });
+      }
+
+      // State: live camera
+
+      {
+        // If there's an active video track from an audio+camera request,
+        // gUM(audio) causes a prompt.
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(true, false);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["microphone"]);
+
+        // Allow and stop the microphone again.
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await checkSharingUI({ audio: true, video: true });
+
+        await stopTracks("audio");
+        await checkSharingUI({ audio: false, video: true });
+      }
+
+      // State: live camera
+
+      {
+        // If there's an active video track from an audio+camera request,
+        // gUM(audio+camera) causes a prompt.
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(true, true);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["microphone", "camera"]);
+
+        // Allow and stop the microphone again.
+        const response = expectObserverCalled("getUserMedia:response:allow");
+        const deviceEvents = expectObserverCalled("recording-device-events");
+        await promiseMessage("ok", () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        });
+        await response;
+        await deviceEvents;
+        Assert.deepEqual(
+          await getMediaCaptureState(),
+          { audio: true, video: true },
+          "expected camera and microphone to be shared"
+        );
+        await checkSharingUI({ audio: true, video: true });
+
+        await stopTracks("audio");
+        await checkSharingUI({ audio: false, video: true });
+      }
+
+      // State: live camera
+
+      {
+        // After closing all streams, gUM(camera) causes a prompt.
+        await closeStream();
+        const request = expectObserverCalled("getUserMedia:request");
+        const popupShown = promisePopupNotificationShown("webRTC-shareDevices");
+        await promiseRequestDevice(false, true);
+        await popupShown;
+        await request;
+        checkDeviceSelectors(["camera"]);
+
+        const response = expectObserverCalled("getUserMedia:response:deny");
+        const windowEnded = expectObserverCalled("recording-window-ended");
+
+        await promiseMessage(permissionError, () => {
+          activateSecondaryAction(kActionDeny);
+        });
+
+        await response;
+        await windowEnded;
+
+        await checkNotSharing();
+        SitePermissions.removeFromPrincipal(
+          null,
+          "camera",
+          gBrowser.selectedBrowser
+        );
+        SitePermissions.removeFromPrincipal(
+          null,
+          "microphone",
+          gBrowser.selectedBrowser
+        );
+      }
+    },
+  },
+
+  {
+    desc: "getUserMedia camera",
+    run: async function checkAudioVideoWhileLiveTracksExist_camera() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+      let indicator = promiseIndicatorWindow();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: false, video: true });
+
+      // If there's an active camera stream,
+      // gUM(audio) causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // gUM(audio+camera) causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // gUM(screen) causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true, null, "screen");
+      await promise;
+      await observerPromise;
+
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+        "webRTC-shareScreen-notification-icon",
+        "anchored to device icon"
+      );
+      checkDeviceSelectors(["screen"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // gUM(camera) returns a stream without prompting.
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+
+      promise = promiseMessage("ok");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await Promise.all(observerPromises);
+
+      await promiseNoPopupNotification("webRTC-shareDevices");
+
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      await checkSharingUI({ audio: false, video: true });
+
+      // close all streams
+      await closeStream();
+    },
+  },
+
+  {
+    desc: "getUserMedia audio",
+    run: async function checkAudioVideoWhileLiveTracksExist_audio() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, false);
+      await promise;
+      await observerPromise;
+      let indicator = promiseIndicatorWindow();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+      await indicator;
+      await checkSharingUI({ audio: true, video: false });
+
+      // If there's an active audio stream,
+      // gUM(camera) causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["camera"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // gUM(audio+camera) causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise = expectObserverCalled("getUserMedia:response:deny");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // gUM(audio) returns a stream without prompting.
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+      promise = promiseMessage("ok");
+      await promiseRequestDevice(true, false);
+      await promise;
+      await observerPromises;
+      await promiseNoPopupNotification("webRTC-shareDevices");
+
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true },
+        "expected microphone to be shared"
+      );
+
+      await checkSharingUI({ audio: true, video: false });
+
+      // close all streams
+      await closeStream();
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_in_frame.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_in_frame.js
new file mode 100644
index 0000000000..15329ec666
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_in_frame.js
@@ -0,0 +1,309 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+var gTests = [
+  {
+    desc: "getUserMedia audio+camera in frame 1",
+    run: async function checkAudioVideoWhileLiveTracksExist_frame() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      info("gUM(audio+camera) in frame 2 should prompt");
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame2");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+
+      // If there's an active audio+camera stream in frame 1,
+      // gUM(audio+camera) in frame 1 returns a stream without prompting;
+      let observerPromises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow"),
+        expectObserverCalled("recording-device-events"),
+      ];
+      promise = promiseMessage("ok");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromises;
+      await promiseNoPopupNotification("webRTC-shareDevices");
+
+      // close the stream
+      await closeStream(false, "frame1");
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+camera in frame 1 - part II",
+    run: async function checkAudioVideoWhileLiveTracksExist_frame_partII() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // If there's an active audio+camera stream in frame 1,
+      // gUM(audio+camera) in the top level window causes a prompt;
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+
+      // close the stream
+      await closeStream(false, "frame1");
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+camera in frame 1 - reload",
+    run: async function checkAudioVideoWhileLiveTracksExist_frame_reload() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // reload frame 1
+      let observerPromises = [
+        expectObserverCalled("recording-device-stopped"),
+        expectObserverCalled("recording-device-events"),
+        expectObserverCalled("recording-window-ended"),
+      ];
+      await promiseReloadFrame("frame1");
+
+      await Promise.all(observerPromises);
+      await checkNotSharing();
+
+      // After the reload,
+      // gUM(audio+camera) in frame 1 causes a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame1");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+
+  {
+    desc: "getUserMedia audio+camera at the top level window",
+    run: async function checkAudioVideoWhileLiveTracksExist_topLevel() {
+      // create an active audio+camera stream at the top level window
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+      let indicator = promiseIndicatorWindow();
+
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ audio: true, video: true });
+
+      // If there's an active audio+camera stream at the top level window,
+      // gUM(audio+camera) in frame 2 causes a prompt.
+      observerPromise = expectObserverCalled("getUserMedia:request");
+      promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(true, true, "frame2");
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      observerPromise1 = expectObserverCalled("getUserMedia:response:deny");
+      observerPromise2 = expectObserverCalled("recording-window-ended");
+
+      await promiseMessage(permissionError, () => {
+        activateSecondaryAction(kActionDeny);
+      });
+
+      await observerPromise1;
+      await observerPromise2;
+
+      // close the stream
+      await closeStream();
+      SitePermissions.removeFromPrincipal(
+        null,
+        "screen",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "camera",
+        gBrowser.selectedBrowser
+      );
+      SitePermissions.removeFromPrincipal(
+        null,
+        "microphone",
+        gBrowser.selectedBrowser
+      );
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests, { relativeURI: "get_user_media_in_frame.html" });
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_queue_request.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_queue_request.js
new file mode 100644
index 0000000000..ed270967d5
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_queue_request.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var gTests = [
+  {
+    desc: "test queueing allow video behind allow video",
+    run: async function testQueuingAllowVideoBehindAllowVideo() {
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      await promiseRequestDevice(false, true);
+      await promiseRequestDevice(false, true);
+      await promise;
+      checkDeviceSelectors(["camera"]);
+      await observerPromise;
+
+      let promises = [
+        expectObserverCalled("getUserMedia:request"),
+        expectObserverCalled("getUserMedia:response:allow", 2),
+        expectObserverCalled("recording-device-events", 2),
+      ];
+
+      await promiseMessage(
+        "ok",
+        () => {
+          PopupNotifications.panel.firstElementChild.button.click();
+        },
+        2
+      );
+      await Promise.all(promises);
+
+      await promiseNoPopupNotification("webRTC-shareDevices");
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { video: true },
+        "expected camera to be shared"
+      );
+
+      // close all streams
+      await closeStream();
+    },
+  },
+];
+
+add_task(async function test() {
+  SimpleTest.requestCompleteLog();
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_tear_off_tab.js b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_tear_off_tab.js
new file mode 100644
index 0000000000..4a48a93853
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_get_user_media_unprompted_access_tear_off_tab.js
@@ -0,0 +1,108 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var gTests = [
+  {
+    desc: "getUserMedia: tearing-off a tab",
+    skipObserverVerification: true,
+    run: async function checkAudioVideoWhileLiveTracksExist_TearingOff() {
+      await enableObserverVerification();
+
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+      checkDeviceSelectors(["microphone", "camera"]);
+
+      let indicator = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+      await promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      await indicator;
+      await checkSharingUI({ video: true, audio: true });
+
+      // Don't listen to observer notifications in the tab any more, as
+      // they will need to be switched to the new window.
+      await disableObserverVerification();
+
+      info("tearing off the tab");
+      let win = gBrowser.replaceTabWithWindow(gBrowser.selectedTab);
+      await whenDelayedStartupFinished(win);
+      await SimpleTest.promiseFocus(win);
+      await checkSharingUI({ audio: true, video: true }, win);
+
+      await enableObserverVerification(win.gBrowser.selectedBrowser);
+
+      info("request audio+video and check if there is no prompt");
+      let observerPromises = [
+        expectObserverCalled(
+          "getUserMedia:request",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+        expectObserverCalled(
+          "getUserMedia:response:allow",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+        expectObserverCalled(
+          "recording-device-events",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+      ];
+      await promiseRequestDevice(
+        true,
+        true,
+        null,
+        null,
+        win.gBrowser.selectedBrowser
+      );
+      await Promise.all(observerPromises);
+
+      await disableObserverVerification();
+
+      observerPromises = [
+        expectObserverCalledOnClose(
+          "recording-device-events",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+        expectObserverCalledOnClose(
+          "recording-window-ended",
+          1,
+          win.gBrowser.selectedBrowser
+        ),
+      ];
+
+      await BrowserTestUtils.closeWindow(win);
+      await Promise.all(observerPromises);
+
+      await checkNotSharing();
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({ set: [["dom.ipc.processCount", 1]] });
+
+  // An empty tab where we can load the content script without leaving it
+  // behind at the end of the test.
+  BrowserTestUtils.addTab(gBrowser);
+
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_devices_select_audio_output.js b/browser/base/content/test/webrtc/browser_devices_select_audio_output.js
new file mode 100644
index 0000000000..87d2d42a3a
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_devices_select_audio_output.js
@@ -0,0 +1,233 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+requestLongerTimeout(2);
+
+const permissionError =
+  "error: NotAllowedError: The request is not allowed " +
+  "by the user agent or the platform in the current context.";
+
+async function requestAudioOutput(options) {
+  await Promise.all([
+    expectObserverCalled("getUserMedia:request"),
+    expectObserverCalled("recording-window-ended"),
+    promiseRequestAudioOutput(options),
+  ]);
+}
+
+async function requestAudioOutputExpectingPrompt(options) {
+  await Promise.all([
+    promisePopupNotificationShown("webRTC-shareDevices"),
+    requestAudioOutput(options),
+  ]);
+
+  is(
+    PopupNotifications.getNotification("webRTC-shareDevices").anchorID,
+    "webRTC-shareSpeaker-notification-icon",
+    "anchored to device icon"
+  );
+  checkDeviceSelectors(["speaker"]);
+}
+
+async function requestAudioOutputExpectingDeny(options) {
+  await Promise.all([
+    requestAudioOutput(options),
+    expectObserverCalled("getUserMedia:response:deny"),
+    promiseMessage(permissionError),
+  ]);
+}
+
+async function simulateAudioOutputRequest(options) {
+  await SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [options],
+    function simPrompt({ deviceCount, deviceId }) {
+      const devices = [...Array(deviceCount).keys()].map(i => ({
+        type: "audiooutput",
+        rawName: `name ${i}`,
+        deviceIndex: i,
+        rawId: `rawId ${i}`,
+        id: `id ${i}`,
+        QueryInterface: ChromeUtils.generateQI([Ci.nsIMediaDevice]),
+      }));
+      const req = {
+        type: "selectaudiooutput",
+        windowID: content.windowGlobalChild.outerWindowId,
+        devices,
+        getConstraints: () => ({}),
+        getAudioOutputOptions: () => ({ deviceId }),
+        isSecure: true,
+        isHandlingUserInput: true,
+      };
+      const { WebRTCChild } = SpecialPowers.ChromeUtils.importESModule(
+        "resource:///actors/WebRTCChild.sys.mjs"
+      );
+      WebRTCChild.observe(req, "getUserMedia:request");
+    }
+  );
+}
+
+async function allowPrompt() {
+  const observerPromise = expectObserverCalled("getUserMedia:response:allow");
+  PopupNotifications.panel.firstElementChild.button.click();
+  await observerPromise;
+}
+
+async function allow() {
+  await Promise.all([promiseMessage("ok"), allowPrompt()]);
+}
+
+async function denyPrompt() {
+  const observerPromise = expectObserverCalled("getUserMedia:response:deny");
+  activateSecondaryAction(kActionDeny);
+  await observerPromise;
+}
+
+async function deny() {
+  await Promise.all([promiseMessage(permissionError), denyPrompt()]);
+}
+
+async function escapePrompt() {
+  const observerPromise = expectObserverCalled("getUserMedia:response:deny");
+  EventUtils.synthesizeKey("KEY_Escape");
+  await observerPromise;
+}
+
+async function escape() {
+  await Promise.all([promiseMessage(permissionError), escapePrompt()]);
+}
+
+var gTests = [
+  {
+    desc: 'User clicks "Allow" and revokes',
+    run: async function checkAllow() {
+      await requestAudioOutputExpectingPrompt();
+      await allow();
+
+      info("selectAudioOutput() with no deviceId again should prompt again.");
+      await requestAudioOutputExpectingPrompt();
+      await allow();
+
+      info("selectAudioOutput() with same deviceId should not prompt again.");
+      await Promise.all([
+        expectObserverCalled("getUserMedia:response:allow"),
+        promiseMessage("ok"),
+        requestAudioOutput({ requestSameDevice: true }),
+      ]);
+
+      await revokePermission("speaker", true);
+      info("Same deviceId should prompt again after revoked permission.");
+      await requestAudioOutputExpectingPrompt({ requestSameDevice: true });
+      await allow();
+      await revokePermission("speaker", true);
+    },
+  },
+  {
+    desc: 'User clicks "Not Now"',
+    run: async function checkNotNow() {
+      await requestAudioOutputExpectingPrompt();
+      is(
+        PopupNotifications.getNotification("webRTC-shareDevices")
+          .secondaryActions[0].label,
+        "Not now",
+        "first secondary action label"
+      );
+      await deny();
+      info("selectAudioOutput() after Not Now should prompt again.");
+      await requestAudioOutputExpectingPrompt();
+      await escape();
+    },
+  },
+  {
+    desc: 'User presses "Esc"',
+    run: async function checkEsc() {
+      await requestAudioOutputExpectingPrompt();
+      await escape();
+      info("selectAudioOutput() after Esc should prompt again.");
+      await requestAudioOutputExpectingPrompt();
+      await allow();
+      await revokePermission("speaker", true);
+    },
+  },
+  {
+    desc: 'User clicks "Always Block"',
+    run: async function checkAlwaysBlock() {
+      await requestAudioOutputExpectingPrompt();
+      await Promise.all([
+        expectObserverCalled("getUserMedia:response:deny"),
+        promiseMessage(permissionError),
+        activateSecondaryAction(kActionNever),
+      ]);
+      info("selectAudioOutput() after Always Block should not prompt again.");
+      await requestAudioOutputExpectingDeny();
+      await revokePermission("speaker", true);
+    },
+  },
+  {
+    desc: "Single Device",
+    run: async function checkSingle() {
+      await Promise.all([
+        promisePopupNotificationShown("webRTC-shareDevices"),
+        simulateAudioOutputRequest({ deviceCount: 1 }),
+      ]);
+      checkDeviceSelectors(["speaker"]);
+      await escapePrompt();
+    },
+  },
+  {
+    desc: "Multi Device with deviceId",
+    run: async function checkMulti() {
+      const deviceCount = 4;
+      await Promise.all([
+        promisePopupNotificationShown("webRTC-shareDevices"),
+        simulateAudioOutputRequest({ deviceCount, deviceId: "id 2" }),
+      ]);
+      const selectorList = document.getElementById(
+        `webRTC-selectSpeaker-menulist`
+      );
+      is(selectorList.selectedIndex, 2, "pre-selected index");
+      checkDeviceSelectors(["speaker"]);
+      await allowPrompt();
+
+      info("Expect same-device request allowed without prompt");
+      await Promise.all([
+        expectObserverCalled("getUserMedia:response:allow"),
+        simulateAudioOutputRequest({ deviceCount, deviceId: "id 2" }),
+      ]);
+
+      info("Expect prompt for different-device request");
+      await Promise.all([
+        promisePopupNotificationShown("webRTC-shareDevices"),
+        simulateAudioOutputRequest({ deviceCount, deviceId: "id 1" }),
+      ]);
+      await denyPrompt();
+
+      info("Expect prompt again for denied-device request");
+      await Promise.all([
+        promisePopupNotificationShown("webRTC-shareDevices"),
+        simulateAudioOutputRequest({ deviceCount, deviceId: "id 1" }),
+      ]);
+      await escapePrompt();
+
+      await revokePermission("speaker", true);
+    },
+  },
+  {
+    desc: "SitePermissions speaker block",
+    run: async function checkPermissionsBlock() {
+      SitePermissions.setForPrincipal(
+        gBrowser.contentPrincipal,
+        "speaker",
+        SitePermissions.BLOCK
+      );
+      await requestAudioOutputExpectingDeny();
+      SitePermissions.removeFromPrincipal(gBrowser.contentPrincipal, "speaker");
+    },
+  },
+];
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({ set: [["media.setsinkid.enabled", true]] });
+  await runTests(gTests);
+});
diff --git a/browser/base/content/test/webrtc/browser_global_mute_toggles.js b/browser/base/content/test/webrtc/browser_global_mute_toggles.js
new file mode 100644
index 0000000000..54713fa8c3
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_global_mute_toggles.js
@@ -0,0 +1,293 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+const MUTE_TOPICS = [
+  "getUserMedia:muteVideo",
+  "getUserMedia:unmuteVideo",
+  "getUserMedia:muteAudio",
+  "getUserMedia:unmuteAudio",
+];
+
+add_setup(async function () {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+    ["privacy.webrtc.globalMuteToggles", true],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+});
+
+/**
+ * Returns a Promise that resolves when the content process for
+ * <browser> fires the right observer notification based on the
+ * value of isMuted for the camera.
+ *
+ * Note: Callers must ensure that they first call
+ * BrowserTestUtils.startObservingTopics to monitor the mute and
+ * unmute observer notifications for this to work properly.
+ *
+ * @param {<xul:browser>} browser - The browser running in the content process
+ * to be monitored.
+ * @param {Boolean} isMuted - True if the muted topic should be fired.
+ * @return {Promise}
+ * @resolves {undefined} When the notification fires.
+ */
+function waitForCameraMuteState(browser, isMuted) {
+  let topic = isMuted ? "getUserMedia:muteVideo" : "getUserMedia:unmuteVideo";
+  return BrowserTestUtils.contentTopicObserved(browser.browsingContext, topic);
+}
+
+/**
+ * Returns a Promise that resolves when the content process for
+ * <browser> fires the right observer notification based on the
+ * value of isMuted for the microphone.
+ *
+ * Note: Callers must ensure that they first call
+ * BrowserTestUtils.startObservingTopics to monitor the mute and
+ * unmute observer notifications for this to work properly.
+ *
+ * @param {<xul:browser>} browser - The browser running in the content process
+ * to be monitored.
+ * @param {Boolean} isMuted - True if the muted topic should be fired.
+ * @return {Promise}
+ * @resolves {undefined} When the notification fires.
+ */
+function waitForMicrophoneMuteState(browser, isMuted) {
+  let topic = isMuted ? "getUserMedia:muteAudio" : "getUserMedia:unmuteAudio";
+  return BrowserTestUtils.contentTopicObserved(browser.browsingContext, topic);
+}
+
+/**
+ * Tests that the global mute toggles fire the right observer
+ * notifications in pre-existing content processes.
+ */
+add_task(async function test_notifications() {
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(browser, true /* camera */, true /* microphone */);
+
+    let indicator = await indicatorPromise;
+    let doc = indicator.document;
+
+    let microphoneMute = doc.getElementById("microphone-mute-toggle");
+    let cameraMute = doc.getElementById("camera-mute-toggle");
+
+    Assert.ok(
+      !microphoneMute.checked,
+      "Microphone toggle should not start checked."
+    );
+    Assert.ok(!cameraMute.checked, "Camera toggle should not start checked.");
+
+    await BrowserTestUtils.startObservingTopics(
+      browser.browsingContext,
+      MUTE_TOPICS
+    );
+
+    info("Muting microphone...");
+    let microphoneMuted = waitForMicrophoneMuteState(browser, true);
+    microphoneMute.click();
+    await microphoneMuted;
+    info("Microphone successfully muted.");
+
+    info("Muting camera...");
+    let cameraMuted = waitForCameraMuteState(browser, true);
+    cameraMute.click();
+    await cameraMuted;
+    info("Camera successfully muted.");
+
+    Assert.ok(
+      microphoneMute.checked,
+      "Microphone toggle should now be checked."
+    );
+    Assert.ok(cameraMute.checked, "Camera toggle should now be checked.");
+
+    info("Unmuting microphone...");
+    let microphoneUnmuted = waitForMicrophoneMuteState(browser, false);
+    microphoneMute.click();
+    await microphoneUnmuted;
+    info("Microphone successfully unmuted.");
+
+    info("Unmuting camera...");
+    let cameraUnmuted = waitForCameraMuteState(browser, false);
+    cameraMute.click();
+    await cameraUnmuted;
+    info("Camera successfully unmuted.");
+
+    await BrowserTestUtils.stopObservingTopics(
+      browser.browsingContext,
+      MUTE_TOPICS
+    );
+  });
+});
+
+/**
+ * Tests that if sharing stops while muted, and the indicator closes,
+ * then the mute state is reset.
+ */
+add_task(async function test_closing_indicator_resets_mute() {
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(browser, true /* camera */, true /* microphone */);
+
+    let indicator = await indicatorPromise;
+    let doc = indicator.document;
+
+    let microphoneMute = doc.getElementById("microphone-mute-toggle");
+    let cameraMute = doc.getElementById("camera-mute-toggle");
+
+    Assert.ok(
+      !microphoneMute.checked,
+      "Microphone toggle should not start checked."
+    );
+    Assert.ok(!cameraMute.checked, "Camera toggle should not start checked.");
+
+    await BrowserTestUtils.startObservingTopics(
+      browser.browsingContext,
+      MUTE_TOPICS
+    );
+
+    info("Muting microphone...");
+    let microphoneMuted = waitForMicrophoneMuteState(browser, true);
+    microphoneMute.click();
+    await microphoneMuted;
+    info("Microphone successfully muted.");
+
+    info("Muting camera...");
+    let cameraMuted = waitForCameraMuteState(browser, true);
+    cameraMute.click();
+    await cameraMuted;
+    info("Camera successfully muted.");
+
+    Assert.ok(
+      microphoneMute.checked,
+      "Microphone toggle should now be checked."
+    );
+    Assert.ok(cameraMute.checked, "Camera toggle should now be checked.");
+
+    let allUnmuted = Promise.all([
+      waitForMicrophoneMuteState(browser, false),
+      waitForCameraMuteState(browser, false),
+    ]);
+
+    await closeStream();
+    await allUnmuted;
+
+    await BrowserTestUtils.stopObservingTopics(
+      browser.browsingContext,
+      MUTE_TOPICS
+    );
+  });
+});
+
+/**
+ * Test that if the global mute state is set, then newly created
+ * content processes also have their tracks muted after sending
+ * a getUserMedia request.
+ */
+add_task(async function test_new_processes() {
+  let tab1 = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: TEST_PAGE,
+  });
+  let browser1 = tab1.linkedBrowser;
+
+  let indicatorPromise = promiseIndicatorWindow();
+
+  await shareDevices(browser1, true /* camera */, true /* microphone */);
+
+  let indicator = await indicatorPromise;
+  let doc = indicator.document;
+
+  let microphoneMute = doc.getElementById("microphone-mute-toggle");
+  let cameraMute = doc.getElementById("camera-mute-toggle");
+
+  Assert.ok(
+    !microphoneMute.checked,
+    "Microphone toggle should not start checked."
+  );
+  Assert.ok(!cameraMute.checked, "Camera toggle should not start checked.");
+
+  await BrowserTestUtils.startObservingTopics(
+    browser1.browsingContext,
+    MUTE_TOPICS
+  );
+
+  info("Muting microphone...");
+  let microphoneMuted = waitForMicrophoneMuteState(browser1, true);
+  microphoneMute.click();
+  await microphoneMuted;
+  info("Microphone successfully muted.");
+
+  info("Muting camera...");
+  let cameraMuted = waitForCameraMuteState(browser1, true);
+  cameraMute.click();
+  await cameraMuted;
+  info("Camera successfully muted.");
+
+  // We'll make sure a new process is being launched by observing
+  // for the ipc:content-created notification.
+  let processLaunched = TestUtils.topicObserved("ipc:content-created");
+
+  let tab2 = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: TEST_PAGE,
+    forceNewProcess: true,
+  });
+  let browser2 = tab2.linkedBrowser;
+
+  await processLaunched;
+
+  await BrowserTestUtils.startObservingTopics(
+    browser2.browsingContext,
+    MUTE_TOPICS
+  );
+
+  let microphoneMuted2 = waitForMicrophoneMuteState(browser2, true);
+  let cameraMuted2 = waitForCameraMuteState(browser2, true);
+  info("Sharing the microphone and camera from a new process.");
+  await shareDevices(browser2, true /* camera */, true /* microphone */);
+  await Promise.all([microphoneMuted2, cameraMuted2]);
+
+  info("Unmuting microphone...");
+  let microphoneUnmuted = Promise.all([
+    waitForMicrophoneMuteState(browser1, false),
+    waitForMicrophoneMuteState(browser2, false),
+  ]);
+  microphoneMute.click();
+  await microphoneUnmuted;
+  info("Microphone successfully unmuted.");
+
+  info("Unmuting camera...");
+  let cameraUnmuted = Promise.all([
+    waitForCameraMuteState(browser1, false),
+    waitForCameraMuteState(browser2, false),
+  ]);
+  cameraMute.click();
+  await cameraUnmuted;
+  info("Camera successfully unmuted.");
+
+  await BrowserTestUtils.stopObservingTopics(
+    browser1.browsingContext,
+    MUTE_TOPICS
+  );
+
+  await BrowserTestUtils.stopObservingTopics(
+    browser2.browsingContext,
+    MUTE_TOPICS
+  );
+
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(tab1);
+});
diff --git a/browser/base/content/test/webrtc/browser_indicator_popuphiding.js b/browser/base/content/test/webrtc/browser_indicator_popuphiding.js
new file mode 100644
index 0000000000..8d02eb5c70
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_indicator_popuphiding.js
@@ -0,0 +1,50 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+/**
+ * Regression test for bug 1668838 - make sure that a popuphiding
+ * event that fires for any popup not related to the device control
+ * menus is ignored and doesn't cause the targets contents to be all
+ * removed.
+ */
+add_task(async function test_popuphiding() {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(
+      browser,
+      true /* camera */,
+      true /* microphone */,
+      SHARE_SCREEN
+    );
+
+    let indicator = await indicatorPromise;
+    let doc = indicator.document;
+
+    Assert.ok(doc.body, "Should have a document body in the indicator.");
+
+    let event = new indicator.MouseEvent("popuphiding", { bubbles: true });
+    doc.documentElement.dispatchEvent(event);
+
+    Assert.ok(doc.body, "Should still have a document body in the indicator.");
+  });
+
+  await checkNotSharing();
+});
diff --git a/browser/base/content/test/webrtc/browser_notification_silencing.js b/browser/base/content/test/webrtc/browser_notification_silencing.js
new file mode 100644
index 0000000000..e2c5c76e2d
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_notification_silencing.js
@@ -0,0 +1,231 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+/**
+ * Tests that the screen / window sharing permission popup offers the ability
+ * for users to silence DOM notifications while sharing.
+ */
+
+/**
+ * Helper function that exercises a specific browser to test whether or not the
+ * user can silence notifications via the display sharing permission panel.
+ *
+ * First, we ensure that notification silencing is disabled by default. Then, we
+ * request screen sharing from the browser, and check the checkbox that
+ * silences notifications. Once screen sharing is established, then we ensure
+ * that notification silencing is enabled. Then we stop sharing, and ensure that
+ * notification silencing is disabled again.
+ *
+ * @param {<xul:browser>} aBrowser - The window to run the test on. This browser
+ *   should have TEST_PAGE loaded.
+ * @return Promise
+ * @resolves undefined - When the test on the browser is complete.
+ */
+async function testNotificationSilencing(aBrowser) {
+  let hasIndicator = Services.wm
+    .getEnumerator("Browser:WebRTCGlobalIndicator")
+    .hasMoreElements();
+
+  let window = aBrowser.ownerGlobal;
+
+  let alertsService = Cc["@mozilla.org/alerts-service;1"]
+    .getService(Ci.nsIAlertsService)
+    .QueryInterface(Ci.nsIAlertsDoNotDisturb);
+  Assert.ok(alertsService, "Alerts Service implements nsIAlertsDoNotDisturb");
+  Assert.ok(
+    !alertsService.suppressForScreenSharing,
+    "Should not be silencing notifications to start."
+  );
+
+  let observerPromise = expectObserverCalled(
+    "getUserMedia:request",
+    1,
+    aBrowser
+  );
+  let promise = promisePopupNotificationShown(
+    "webRTC-shareDevices",
+    null,
+    window
+  );
+  let indicatorPromise = hasIndicator
+    ? Promise.resolve()
+    : promiseIndicatorWindow();
+  await promiseRequestDevice(false, true, null, "screen", aBrowser);
+  await promise;
+  await observerPromise;
+
+  checkDeviceSelectors(["screen"], window);
+
+  let document = window.document;
+
+  // Select one of the windows / screens. It doesn't really matter which.
+  let menulist = document.getElementById("webRTC-selectWindow-menulist");
+  menulist.getItemAtIndex(menulist.itemCount - 1).doCommand();
+
+  let notification = window.PopupNotifications.panel.firstElementChild;
+  Assert.ok(
+    notification.hasAttribute("warninghidden"),
+    "Notification silencing warning message is hidden by default"
+  );
+
+  let checkbox = notification.checkbox;
+  Assert.ok(!!checkbox, "Notification silencing checkbox is present");
+  Assert.ok(!checkbox.checked, "checkbox is not checked by default");
+  checkbox.click();
+  Assert.ok(checkbox.checked, "checkbox now checked");
+  // The orginal behaviour of the checkbox disabled the Allow button. Let's
+  // make sure we're not still doing that.
+  Assert.ok(!notification.button.disabled, "Allow button is not disabled");
+  Assert.ok(
+    notification.hasAttribute("warninghidden"),
+    "No warning message is shown"
+  );
+
+  let observerPromise1 = expectObserverCalled(
+    "getUserMedia:response:allow",
+    1,
+    aBrowser
+  );
+  let observerPromise2 = expectObserverCalled(
+    "recording-device-events",
+    1,
+    aBrowser
+  );
+  await promiseMessage(
+    "ok",
+    () => {
+      notification.button.click();
+    },
+    1,
+    aBrowser
+  );
+  await observerPromise1;
+  await observerPromise2;
+  let indicator = await indicatorPromise;
+
+  Assert.ok(
+    alertsService.suppressForScreenSharing,
+    "Should now be silencing notifications"
+  );
+
+  let indicatorClosedPromise = hasIndicator
+    ? Promise.resolve()
+    : BrowserTestUtils.domWindowClosed(indicator);
+
+  await stopSharing("screen", true, aBrowser, window);
+  await indicatorClosedPromise;
+
+  Assert.ok(
+    !alertsService.suppressForScreenSharing,
+    "Should no longer be silencing notifications"
+  );
+}
+
+add_setup(async function () {
+  // Set prefs so that permissions prompts are shown and loopback devices
+  // are not used. To test the chrome we want prompts to be shown, and
+  // these tests are flakey when using loopback devices (though it would
+  // be desirable to make them work with loopback in future). See bug 1643711.
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+});
+
+/**
+ * Tests notification silencing in a normal browser window.
+ */
+add_task(async function testNormalWindow() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: TEST_PAGE,
+    },
+    async browser => {
+      await testNotificationSilencing(browser);
+    }
+  );
+});
+
+/**
+ * Tests notification silencing in a private browser window.
+ */
+add_task(async function testPrivateWindow() {
+  let privateWindow = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser: privateWindow.gBrowser,
+      url: TEST_PAGE,
+    },
+    async browser => {
+      await testNotificationSilencing(browser);
+    }
+  );
+
+  await BrowserTestUtils.closeWindow(privateWindow);
+});
+
+/**
+ * Tests notification silencing when sharing a screen while already
+ * sharing the microphone. Alone ensures that if we stop sharing the
+ * screen, but continue sharing the microphone, that notification
+ * silencing ends.
+ */
+add_task(async function testWhileSharingMic() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: TEST_PAGE,
+    },
+    async browser => {
+      let promise = promisePopupNotificationShown("webRTC-shareDevices");
+      let observerPromise = expectObserverCalled("getUserMedia:request");
+      await promiseRequestDevice(true, true);
+      await promise;
+      await observerPromise;
+
+      let indicatorPromise = promiseIndicatorWindow();
+      let observerPromise1 = expectObserverCalled(
+        "getUserMedia:response:allow"
+      );
+      let observerPromise2 = expectObserverCalled("recording-device-events");
+
+      promise = promiseMessage("ok", () => {
+        PopupNotifications.panel.firstElementChild.button.click();
+      });
+      await observerPromise1;
+      await observerPromise2;
+      await promise;
+
+      Assert.deepEqual(
+        await getMediaCaptureState(),
+        { audio: true, video: true },
+        "expected camera and microphone to be shared"
+      );
+
+      let indicator = await indicatorPromise;
+      await checkSharingUI({ audio: true, video: true });
+
+      await testNotificationSilencing(browser);
+
+      let indicatorClosedPromise = BrowserTestUtils.domWindowClosed(indicator);
+      await closeStream();
+      await indicatorClosedPromise;
+    }
+  );
+});
diff --git a/browser/base/content/test/webrtc/browser_stop_sharing_button.js b/browser/base/content/test/webrtc/browser_stop_sharing_button.js
new file mode 100644
index 0000000000..17ab66abc4
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_stop_sharing_button.js
@@ -0,0 +1,175 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+add_setup(async function () {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+});
+
+/**
+ * Tests that if the user chooses to "Stop Sharing" a display while
+ * also sharing their microphone or camera, that only the display
+ * stream is stopped.
+ */
+add_task(async function test_stop_sharing() {
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(
+      browser,
+      true /* camera */,
+      true /* microphone */,
+      SHARE_SCREEN
+    );
+
+    let indicator = await indicatorPromise;
+
+    let stopSharingButton = indicator.document.getElementById("stop-sharing");
+    let stopSharingPromise = expectObserverCalled("recording-device-events");
+    stopSharingButton.click();
+    await stopSharingPromise;
+
+    // Ensure that we're still sharing the other streams.
+    await checkSharingUI({ audio: true, video: true });
+
+    // Ensure that the "display-share" section of the indicator is now hidden
+    Assert.ok(
+      BrowserTestUtils.is_hidden(
+        indicator.document.getElementById("display-share")
+      ),
+      "The display-share section of the indicator should now be hidden."
+    );
+  });
+});
+
+/**
+ * Tests that if the user chooses to "Stop Sharing" a display while
+ * sharing their display on multiple sites, all of those display sharing
+ * streams are closed.
+ */
+add_task(async function test_stop_sharing_multiple() {
+  let indicatorPromise = promiseIndicatorWindow();
+
+  info("Opening first tab");
+  let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera, microphone and screen");
+  await shareDevices(tab1.linkedBrowser, true, true, SHARE_SCREEN);
+
+  info("Opening second tab");
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera and screen");
+  await shareDevices(tab2.linkedBrowser, true, false, SHARE_SCREEN);
+
+  let indicator = await indicatorPromise;
+
+  let stopSharingButton = indicator.document.getElementById("stop-sharing");
+  let stopSharingPromise = TestUtils.waitForCondition(() => {
+    return !webrtcUI.showScreenSharingIndicator;
+  });
+  stopSharingButton.click();
+  await stopSharingPromise;
+
+  Assert.equal(gBrowser.selectedTab, tab2, "Should have tab2 selected.");
+  await checkSharingUI({ audio: false, video: true }, window, {
+    audio: true,
+    video: true,
+  });
+  BrowserTestUtils.removeTab(tab2);
+
+  Assert.equal(gBrowser.selectedTab, tab1, "Should have tab1 selected.");
+  await checkSharingUI({ audio: true, video: true }, window, {
+    audio: true,
+    video: true,
+  });
+
+  // Ensure that the "display-share" section of the indicator is now hidden
+  Assert.ok(
+    BrowserTestUtils.is_hidden(
+      indicator.document.getElementById("display-share")
+    ),
+    "The display-share section of the indicator should now be hidden."
+  );
+
+  BrowserTestUtils.removeTab(tab1);
+});
+
+/**
+ * Tests that if the user chooses to "Stop Sharing" a display, persistent
+ * permissions are not removed for camera or microphone devices.
+ */
+add_task(async function test_keep_permissions() {
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let indicatorPromise = promiseIndicatorWindow();
+
+    await shareDevices(
+      browser,
+      true /* camera */,
+      true /* microphone */,
+      SHARE_SCREEN,
+      true /* remember */
+    );
+
+    let indicator = await indicatorPromise;
+
+    let stopSharingButton = indicator.document.getElementById("stop-sharing");
+    let stopSharingPromise = expectObserverCalled("recording-device-events");
+    stopSharingButton.click();
+    await stopSharingPromise;
+
+    // Ensure that we're still sharing the other streams.
+    await checkSharingUI({ audio: true, video: true }, undefined, undefined, {
+      audio: { scope: SitePermissions.SCOPE_PERSISTENT },
+      video: { scope: SitePermissions.SCOPE_PERSISTENT },
+    });
+
+    // Ensure that the "display-share" section of the indicator is now hidden
+    Assert.ok(
+      BrowserTestUtils.is_hidden(
+        indicator.document.getElementById("display-share")
+      ),
+      "The display-share section of the indicator should now be hidden."
+    );
+
+    let { state: micState, scope: micScope } = SitePermissions.getForPrincipal(
+      browser.contentPrincipal,
+      "microphone",
+      browser
+    );
+
+    Assert.equal(micState, SitePermissions.ALLOW);
+    Assert.equal(micScope, SitePermissions.SCOPE_PERSISTENT);
+
+    let { state: camState, scope: camScope } = SitePermissions.getForPrincipal(
+      browser.contentPrincipal,
+      "camera",
+      browser
+    );
+    Assert.equal(camState, SitePermissions.ALLOW);
+    Assert.equal(camScope, SitePermissions.SCOPE_PERSISTENT);
+
+    SitePermissions.removeFromPrincipal(
+      browser.contentPrincipal,
+      "camera",
+      browser
+    );
+    SitePermissions.removeFromPrincipal(
+      browser.contentPrincipal,
+      "microphone",
+      browser
+    );
+  });
+});
diff --git a/browser/base/content/test/webrtc/browser_stop_streams_on_indicator_close.js b/browser/base/content/test/webrtc/browser_stop_streams_on_indicator_close.js
new file mode 100644
index 0000000000..b5d4229fdc
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_stop_streams_on_indicator_close.js
@@ -0,0 +1,215 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "https://example.com/"
+);
+const TEST_PAGE = TEST_ROOT + "get_user_media.html";
+
+add_setup(async function () {
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+});
+
+/**
+ * Tests that if the indicator is closed somehow by the user when streams
+ * still ongoing, that all of those streams it represents are stopped, and
+ * the most recent tab that a stream was shared with is selected.
+ *
+ * This test makes sure the global mute toggles for camera and microphone
+ * are disabled, so the indicator only represents display streams, and only
+ * those streams should be stopped on close.
+ */
+add_task(async function test_close_indicator_no_global_toggles() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.webrtc.globalMuteToggles", false]],
+  });
+
+  let indicatorPromise = promiseIndicatorWindow();
+
+  info("Opening first tab");
+  let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera, microphone and screen");
+  await shareDevices(tab1.linkedBrowser, true, true, SHARE_SCREEN, false);
+
+  info("Opening second tab");
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera, microphone and screen");
+  await shareDevices(tab2.linkedBrowser, true, true, SHARE_SCREEN, true);
+
+  info("Opening third tab");
+  let tab3 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing screen");
+  await shareDevices(tab3.linkedBrowser, false, false, SHARE_SCREEN, false);
+
+  info("Opening fourth tab");
+  let tab4 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "https://example.com"
+  );
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    tab4,
+    "Most recently opened tab is selected"
+  );
+
+  let indicator = await indicatorPromise;
+
+  indicator.close();
+
+  // Wait a tick of the event loop to give the unload handler in the indicator
+  // a chance to run.
+  await new Promise(resolve => executeSoon(resolve));
+
+  // Make sure the media capture state has a chance to flush up to the parent.
+  await getMediaCaptureState();
+
+  // The camera and microphone streams should still be active.
+  let camStreams = webrtcUI.getActiveStreams(true, false);
+  Assert.equal(camStreams.length, 2, "Should have found two camera streams");
+  let micStreams = webrtcUI.getActiveStreams(false, true);
+  Assert.equal(
+    micStreams.length,
+    2,
+    "Should have found two microphone streams"
+  );
+
+  // The camera and microphone permission were remembered for tab2, so check to
+  // make sure that the permissions remain.
+  let { state: camState, scope: camScope } = SitePermissions.getForPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "camera",
+    tab2.linkedBrowser
+  );
+  Assert.equal(camState, SitePermissions.ALLOW);
+  Assert.equal(camScope, SitePermissions.SCOPE_PERSISTENT);
+
+  let { state: micState, scope: micScope } = SitePermissions.getForPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "microphone",
+    tab2.linkedBrowser
+  );
+  Assert.equal(micState, SitePermissions.ALLOW);
+  Assert.equal(micScope, SitePermissions.SCOPE_PERSISTENT);
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    tab3,
+    "Most recently tab that streams were shared with is selected"
+  );
+
+  SitePermissions.removeFromPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "camera",
+    tab2.linkedBrowser
+  );
+
+  SitePermissions.removeFromPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "microphone",
+    tab2.linkedBrowser
+  );
+
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(tab3);
+  BrowserTestUtils.removeTab(tab4);
+});
+
+/**
+ * Tests that if the indicator is closed somehow by the user when streams
+ * still ongoing, that all of those streams is represents are stopped, and
+ * the most recent tab that a stream was shared with is selected.
+ *
+ * This test makes sure the global mute toggles are enabled. This means that
+ * when the user manages to close the indicator, we should revoke camera
+ * and microphone permissions too.
+ */
+add_task(async function test_close_indicator_with_global_toggles() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.webrtc.globalMuteToggles", true]],
+  });
+
+  let indicatorPromise = promiseIndicatorWindow();
+
+  info("Opening first tab");
+  let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera, microphone and screen");
+  await shareDevices(tab1.linkedBrowser, true, true, SHARE_SCREEN, false);
+
+  info("Opening second tab");
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing camera, microphone and screen");
+  await shareDevices(tab2.linkedBrowser, true, true, SHARE_SCREEN, true);
+
+  info("Opening third tab");
+  let tab3 = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE);
+  info("Sharing screen");
+  await shareDevices(tab3.linkedBrowser, false, false, SHARE_SCREEN, false);
+
+  info("Opening fourth tab");
+  let tab4 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "https://example.com"
+  );
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    tab4,
+    "Most recently opened tab is selected"
+  );
+
+  let indicator = await indicatorPromise;
+
+  indicator.close();
+
+  // Wait a tick of the event loop to give the unload handler in the indicator
+  // a chance to run.
+  await new Promise(resolve => executeSoon(resolve));
+
+  Assert.deepEqual(
+    await getMediaCaptureState(),
+    {},
+    "expected nothing to be shared"
+  );
+
+  // Ensuring we no longer have any active streams.
+  let streams = webrtcUI.getActiveStreams(true, true, true, true);
+  Assert.equal(streams.length, 0, "Should have found no active streams");
+
+  // The camera and microphone permissions should have been cleared.
+  let { state: camState } = SitePermissions.getForPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "camera",
+    tab2.linkedBrowser
+  );
+  Assert.equal(camState, SitePermissions.UNKNOWN);
+
+  let { state: micState } = SitePermissions.getForPrincipal(
+    tab2.linkedBrowser.contentPrincipal,
+    "microphone",
+    tab2.linkedBrowser
+  );
+  Assert.equal(micState, SitePermissions.UNKNOWN);
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    tab3,
+    "Most recently tab that streams were shared with is selected"
+  );
+
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(tab3);
+  BrowserTestUtils.removeTab(tab4);
+});
diff --git a/browser/base/content/test/webrtc/browser_tab_switch_warning.js b/browser/base/content/test/webrtc/browser_tab_switch_warning.js
new file mode 100644
index 0000000000..f0625ab4ca
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_tab_switch_warning.js
@@ -0,0 +1,538 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Tests the warning that is displayed when switching to background
+ * tabs when sharing the browser window or screen
+ */
+
+// The number of tabs to have in the background for testing.
+const NEW_BACKGROUND_TABS_TO_OPEN = 5;
+const WARNING_PANEL_ID = "sharing-tabs-warning-panel";
+const ALLOW_BUTTON_ID = "sharing-warning-proceed-to-tab";
+const DISABLE_WARNING_FOR_SESSION_CHECKBOX_ID =
+  "sharing-warning-disable-for-session";
+const WINDOW_SHARING_HEADER_ID = "sharing-warning-window-panel-header";
+const SCREEN_SHARING_HEADER_ID = "sharing-warning-screen-panel-header";
+// The number of milliseconds we're willing to wait for the
+// warning panel before we decide that it's not coming.
+const WARNING_PANEL_TIMEOUT_MS = 1000;
+const CTRL_TAB_RUO_PREF = "browser.ctrlTab.sortByRecentlyUsed";
+
+/**
+ * Common helper function that pretendToShareWindow and pretendToShareScreen
+ * call into. Ensures that the first tab is selected, and then (optionally)
+ * does the first "freebie" tab switch to the second tab.
+ *
+ * @param {boolean} doFirstTabSwitch - True if this function should take
+ *   care of doing the "freebie" tab switch for you.
+ * @return {Promise}
+ * @resolves {undefined} - Once the simulation is set up.
+ */
+async function pretendToShareDisplay(doFirstTabSwitch) {
+  Assert.equal(
+    gBrowser.selectedTab,
+    gBrowser.tabs[0],
+    "Should start on the first tab."
+  );
+
+  webrtcUI.sharingDisplay = true;
+  if (doFirstTabSwitch) {
+    await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[1]);
+  }
+}
+
+/**
+ * Simulates the sharing of a particular browser window. The
+ * simulation doesn't actually share the window over WebRTC, but
+ * does enough to convince webrtcUI that the window is in the shared
+ * window list.
+ *
+ * It is assumed that the first tab is the selected tab when calling
+ * this function.
+ *
+ * This helper function can also automatically perform the first
+ * "freebie" tab switch that never warns. This is its default behaviour.
+ *
+ * @param {DOM Window} aWindow - The window that we're simulating sharing.
+ * @param {boolean} doFirstTabSwitch - True if this function should take
+ *   care of doing the "freebie" tab switch for you. Defaults to true.
+ * @return {Promise}
+ * @resolves {undefined} - Once the simulation is set up.
+ */
+async function pretendToShareWindow(aWindow, doFirstTabSwitch = true) {
+  // Poke into webrtcUI so that it thinks that the current browser
+  // window is being shared.
+  webrtcUI.sharedBrowserWindows.add(aWindow);
+  await pretendToShareDisplay(doFirstTabSwitch);
+}
+
+/**
+ * Simulates the sharing of the screen. The simulation doesn't actually share
+ * the screen over WebRTC, but does enough to convince webrtcUI that the screen
+ * is being shared.
+ *
+ * It is assumed that the first tab is the selected tab when calling
+ * this function.
+ *
+ * This helper function can also automatically perform the first
+ * "freebie" tab switch that never warns. This is its default behaviour.
+ *
+ * @param {boolean} doFirstTabSwitch - True if this function should take
+ *   care of doing the "freebie" tab switch for you. Defaults to true.
+ * @return {Promise}
+ * @resolves {undefined} - Once the simulation is set up.
+ */
+async function pretendToShareScreen(doFirstTabSwitch = true) {
+  // Poke into webrtcUI so that it thinks that the current screen is being
+  // shared.
+  webrtcUI.sharingScreen = true;
+  await pretendToShareDisplay(doFirstTabSwitch);
+}
+
+/**
+ * Resets webrtcUI's notion of what is being shared. This also clears
+ * out any simulated shared windows, and resets any state that only
+ * persists for a sharing session.
+ *
+ * This helper function will also:
+ * 1. Switch back to the first tab if it's not already selected.
+ * 2. Check if the tab switch warning panel is open, and if so, close it.
+ *
+ * @return {Promise}
+ * @resolves {undefined} - Once the state is reset.
+ */
+async function resetDisplaySharingState() {
+  let firstTabBC = gBrowser.browsers[0].browsingContext;
+  webrtcUI.streamAddedOrRemoved(firstTabBC, { remove: true });
+
+  if (gBrowser.selectedTab !== gBrowser.tabs[0]) {
+    await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[0]);
+  }
+
+  let panel = document.getElementById(WARNING_PANEL_ID);
+  if (panel && (panel.state == "open" || panel.state == "showing")) {
+    info("Closing the warning panel.");
+    let panelHidden = BrowserTestUtils.waitForEvent(panel, "popuphidden");
+    panel.hidePopup();
+    await panelHidden;
+  }
+}
+
+/**
+ * Checks to make sure that a tab switch warning doesn't show
+ * within WARNING_PANEL_TIMEOUT_MS milliseconds.
+ *
+ * @return {Promise}
+ * @resolves {undefined} - Once the check is complete.
+ */
+async function ensureNoWarning() {
+  let timerExpired = false;
+  let sawWarning = false;
+
+  let resolver;
+  let timeoutOrPopupShowingPromise = new Promise(resolve => {
+    resolver = resolve;
+  });
+
+  let onPopupShowing = event => {
+    if (event.target.id == WARNING_PANEL_ID) {
+      sawWarning = true;
+      resolver();
+    }
+  };
+  // The panel might not have been lazily-inserted yet, so we
+  // attach the popupshowing handler to the window instead.
+  window.addEventListener("popupshowing", onPopupShowing);
+
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  let timer = setTimeout(() => {
+    timerExpired = true;
+    resolver();
+  }, WARNING_PANEL_TIMEOUT_MS);
+
+  await timeoutOrPopupShowingPromise;
+
+  clearTimeout(timer);
+  window.removeEventListener("popupshowing", onPopupShowing);
+
+  Assert.ok(timerExpired, "Timer should have expired.");
+  Assert.ok(!sawWarning, "Should not have shown the tab switch warning.");
+}
+
+/**
+ * Checks to make sure that a tab switch warning appears for
+ * a particular tab.
+ *
+ * @param {<xul:tab>} tab - The tab that the warning should be anchored to.
+ * @return {Promise}
+ * @resolves {undefined} - Once the check is complete.
+ */
+async function ensureWarning(tab) {
+  let popupShowingEvent = await BrowserTestUtils.waitForEvent(
+    window,
+    "popupshowing",
+    false,
+    event => {
+      return event.target.id == WARNING_PANEL_ID;
+    }
+  );
+  let panel = popupShowingEvent.target;
+
+  Assert.equal(
+    panel.anchorNode,
+    tab,
+    "Expected the warning to be anchored to the right tab."
+  );
+}
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.webrtc.sharedTabWarning", true]],
+  });
+
+  // Loads up NEW_BACKGROUND_TABS_TO_OPEN background tabs at about:blank,
+  // and waits until they're fully open.
+  let uris = new Array(NEW_BACKGROUND_TABS_TO_OPEN).fill("about:blank");
+
+  let loadPromises = Promise.all(
+    uris.map(uri => BrowserTestUtils.waitForNewTab(gBrowser, uri, false, true))
+  );
+
+  gBrowser.loadTabs(uris, {
+    inBackground: true,
+    triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+  });
+
+  await loadPromises;
+
+  // Switches to the first tab and closes all of the rest.
+  registerCleanupFunction(async () => {
+    await resetDisplaySharingState();
+    gBrowser.removeAllTabsBut(gBrowser.tabs[0]);
+  });
+});
+
+/**
+ * Tests that when sharing the window that the first tab switch does _not_ show
+ * the warning. This is because we presume that the first tab switch since
+ * starting display sharing is for a tab that is intentionally being shared.
+ */
+add_task(async function testFirstTabSwitchAllowed() {
+  pretendToShareWindow(window, false);
+
+  let targetTab = gBrowser.tabs[1];
+
+  let noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await noWarningPromise;
+
+  await resetDisplaySharingState();
+});
+
+/**
+ * Tests that the second tab switch after sharing is not allowed
+ * without a warning. Also tests that the warning can "allow"
+ * the tab switch to proceed, and that no warning is subsequently
+ * shown for the "allowed" tab. Finally, ensures that if the sharing
+ * session ends and a new session begins, that warnings are shown
+ * again for the allowed tabs.
+ */
+add_task(async function testWarningOnSecondTabSwitch() {
+  pretendToShareWindow(window);
+  let originalTab = gBrowser.selectedTab;
+
+  // pretendToShareWindow will have switched us to the second
+  // tab automatically as the first "freebie" tab switch
+
+  let targetTab = gBrowser.tabs[2];
+
+  // Ensure that we show the warning on the second tab switch
+  let warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  // Not only should we have warned, but we should have prevented
+  // the tab switch from occurring.
+  Assert.equal(
+    gBrowser.selectedTab,
+    originalTab,
+    "Should still be on the original tab."
+  );
+
+  // Now test the "Allow" button in the warning to make sure the tab
+  // switch goes through.
+  let tabSwitchPromise = BrowserTestUtils.waitForEvent(
+    gBrowser,
+    "TabSwitchDone"
+  );
+  let allowButton = document.getElementById(ALLOW_BUTTON_ID);
+  allowButton.click();
+  await tabSwitchPromise;
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    targetTab,
+    "Should have switched tabs to the target."
+  );
+
+  // We shouldn't see a warning when switching back to that first
+  // "freebie" tab.
+  let noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, originalTab);
+  await noWarningPromise;
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    originalTab,
+    "Should have switched tabs back to the original tab."
+  );
+
+  // We shouldn't see a warning when switching back to the tab that
+  // we had just allowed.
+  noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await noWarningPromise;
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    targetTab,
+    "Should have switched tabs back to the target tab."
+  );
+
+  // Reset the sharing state, and make sure that warnings can
+  // be displayed again.
+  await resetDisplaySharingState();
+  pretendToShareWindow(window);
+
+  // pretendToShareWindow will have switched us to the second
+  // tab automatically as the first "freebie" tab switch
+  //
+  // Make sure we get the warning again when switching to the
+  // target tab.
+  warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  await resetDisplaySharingState();
+});
+
+/**
+ * Tests that warnings can be skipped for a session via the
+ * checkbox in the warning panel. Also checks that once the
+ * session ends and a new one begins that warnings are displayed
+ * again.
+ */
+add_task(async function testDisableWarningForSession() {
+  pretendToShareWindow(window);
+
+  // pretendToShareWindow will have switched us to the second
+  // tab automatically as the first "freebie" tab switch
+  let targetTab = gBrowser.tabs[2];
+
+  // Ensure that we show the warning on the second tab switch
+  let warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  // Check the checkbox to suppress warnings for the rest of this session.
+  let checkbox = document.getElementById(
+    DISABLE_WARNING_FOR_SESSION_CHECKBOX_ID
+  );
+  checkbox.checked = true;
+
+  // Now test the "Allow" button in the warning to make sure the tab
+  // switch goes through.
+  let tabSwitchPromise = BrowserTestUtils.waitForEvent(
+    gBrowser,
+    "TabSwitchDone"
+  );
+  let allowButton = document.getElementById(ALLOW_BUTTON_ID);
+  allowButton.click();
+  await tabSwitchPromise;
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    targetTab,
+    "Should have switched tabs to the target tab."
+  );
+
+  // Switching to the 4th and 5th tabs should now not show warnings.
+  let noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[3]);
+  await noWarningPromise;
+
+  noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[4]);
+  await noWarningPromise;
+
+  // Reset the sharing state, and make sure that warnings can
+  // be displayed again.
+  await resetDisplaySharingState();
+  pretendToShareWindow(window);
+
+  // pretendToShareWindow will have switched us to the second
+  // tab automatically as the first "freebie" tab switch
+  //
+  // Make sure we get the warning again when switching to the
+  // target tab.
+  warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  await resetDisplaySharingState();
+});
+
+/**
+ * Tests that we don't show a warning when sharing a different
+ * window than the one we're switching tabs in.
+ */
+add_task(async function testOtherWindow() {
+  let otherWin = await BrowserTestUtils.openNewBrowserWindow();
+  await SimpleTest.promiseFocus(window);
+  pretendToShareWindow(otherWin);
+
+  // Switching to the 4th and 5th tabs should now not show warnings.
+  let noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[3]);
+  await noWarningPromise;
+
+  noWarningPromise = ensureNoWarning();
+  await BrowserTestUtils.switchTab(gBrowser, gBrowser.tabs[4]);
+  await noWarningPromise;
+
+  await BrowserTestUtils.closeWindow(otherWin);
+
+  await resetDisplaySharingState();
+});
+
+/**
+ * Tests that we show a different label when sharing the screen
+ * vs when sharing a window.
+ */
+add_task(async function testWindowVsScreenLabel() {
+  pretendToShareWindow(window);
+
+  // pretendToShareWindow will have switched us to the second
+  // tab automatically as the first "freebie" tab switch.
+  // Let's now switch to the third tab.
+  let targetTab = gBrowser.tabs[2];
+
+  // Ensure that we show the warning on this second tab switch
+  let warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  let windowHeader = document.getElementById(WINDOW_SHARING_HEADER_ID);
+  let screenHeader = document.getElementById(SCREEN_SHARING_HEADER_ID);
+  Assert.ok(
+    !BrowserTestUtils.is_hidden(windowHeader),
+    "Should be showing window sharing header"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_hidden(screenHeader),
+    "Should not be showing screen sharing header"
+  );
+
+  // Reset the sharing state, and then pretend to share the screen.
+  await resetDisplaySharingState();
+  pretendToShareScreen();
+
+  // Ensure that we show the warning on this second tab switch
+  warningPromise = ensureWarning(targetTab);
+  await BrowserTestUtils.switchTab(gBrowser, targetTab);
+  await warningPromise;
+
+  Assert.ok(
+    BrowserTestUtils.is_hidden(windowHeader),
+    "Should not be showing window sharing header"
+  );
+  Assert.ok(
+    !BrowserTestUtils.is_hidden(screenHeader),
+    "Should be showing screen sharing header"
+  );
+  await resetDisplaySharingState();
+});
+
+/**
+ * Tests that tab switching via the keyboard can also trigger the
+ * tab switch warnings.
+ */
+add_task(async function testKeyboardTabSwitching() {
+  let pressCtrlTab = async (expectPanel = false) => {
+    let promise;
+    if (expectPanel) {
+      promise = BrowserTestUtils.waitForEvent(ctrlTab.panel, "popupshown");
+    } else {
+      promise = BrowserTestUtils.waitForEvent(document, "keyup");
+    }
+    EventUtils.synthesizeKey("VK_TAB", {
+      ctrlKey: true,
+      shiftKey: false,
+    });
+    await promise;
+  };
+
+  let releaseCtrl = async () => {
+    let promise;
+    if (ctrlTab.isOpen) {
+      promise = BrowserTestUtils.waitForEvent(ctrlTab.panel, "popuphidden");
+    } else {
+      promise = BrowserTestUtils.waitForEvent(document, "keyup");
+    }
+    EventUtils.synthesizeKey("VK_CONTROL", { type: "keyup" });
+    return promise;
+  };
+
+  // Ensure that the (on by default) ctrl-tab switch panel is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [[CTRL_TAB_RUO_PREF, true]],
+  });
+
+  pretendToShareWindow(window);
+  let originalTab = gBrowser.selectedTab;
+  await pressCtrlTab(true);
+
+  // The Ctrl-Tab MRU list should be:
+  // 0: Second tab (currently selected)
+  // 1: First tab
+  // 2: Last tab
+  //
+  // Having pressed Ctrl-Tab once, 1 (First tab) is selected in the
+  // panel. We want a tab that will warn, so let's hit Ctrl-Tab again
+  // to choose 2 (Last tab).
+  let targetTab = ctrlTab.tabList[2];
+  await pressCtrlTab();
+
+  let warningPromise = ensureWarning(targetTab);
+  await releaseCtrl();
+  await warningPromise;
+
+  // Hide the warning without allowing the tab switch.
+  let panel = document.getElementById(WARNING_PANEL_ID);
+  panel.hidePopup();
+
+  Assert.equal(
+    gBrowser.selectedTab,
+    originalTab,
+    "Should not have changed from the original tab."
+  );
+
+  // Now switch to the in-order tab switching keyboard shortcut mode.
+  await SpecialPowers.popPrefEnv();
+  await SpecialPowers.pushPrefEnv({
+    set: [[CTRL_TAB_RUO_PREF, false]],
+  });
+
+  // Hitting Ctrl-Tab should choose the _next_ tab over from
+  // the originalTab, which should be the third tab.
+  targetTab = gBrowser.tabs[2];
+
+  warningPromise = ensureWarning(targetTab);
+  await pressCtrlTab();
+  await warningPromise;
+
+  await resetDisplaySharingState();
+});
diff --git a/browser/base/content/test/webrtc/browser_webrtc_hooks.js b/browser/base/content/test/webrtc/browser_webrtc_hooks.js
new file mode 100644
index 0000000000..e980b15286
--- /dev/null
+++ b/browser/base/content/test/webrtc/browser_webrtc_hooks.js
@@ -0,0 +1,371 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const ORIGIN = "https://example.com";
+
+async function tryPeerConnection(browser, expectedError = null) {
+  let errtype = await SpecialPowers.spawn(browser, [], async function () {
+    let pc = new content.RTCPeerConnection();
+    try {
+      await pc.createOffer({ offerToReceiveAudio: true });
+      return null;
+    } catch (err) {
+      return err.name;
+    }
+  });
+
+  let detail = expectedError
+    ? `createOffer() threw a ${expectedError}`
+    : "createOffer() succeeded";
+  is(errtype, expectedError, detail);
+}
+
+// Helper for tests that use the peer-request-allowed and -blocked events.
+// A test that expects some of those events does the following:
+//  - call Events.on() before the test to setup event handlers
+//  - call Events.expect(name) after a specific event is expected to have
+//    occured.  This will fail if the event didn't occur, and will return
+//    the details passed to the handler for furhter checking.
+//  - call Events.off() at the end of the test to clean up.  At this point, if
+//    any events were triggered that the test did not expect, the test fails.
+const Events = {
+  events: ["peer-request-allowed", "peer-request-blocked"],
+  details: new Map(),
+  handlers: new Map(),
+  on() {
+    for (let event of this.events) {
+      let handler = data => {
+        if (this.details.has(event)) {
+          ok(false, `Got multiple ${event} events`);
+        }
+        this.details.set(event, data);
+      };
+      webrtcUI.on(event, handler);
+      this.handlers.set(event, handler);
+    }
+  },
+  expect(event) {
+    let result = this.details.get(event);
+    isnot(result, undefined, `${event} event was triggered`);
+    this.details.delete(event);
+
+    // All events should have a good origin
+    is(result.origin, ORIGIN, `${event} event has correct origin`);
+
+    return result;
+  },
+  off() {
+    for (let event of this.events) {
+      webrtcUI.off(event, this.handlers.get(event));
+      this.handlers.delete(event);
+    }
+    for (let [event] of this.details) {
+      ok(false, `Got unexpected event ${event}`);
+    }
+  },
+};
+
+var gTests = [
+  {
+    desc: "Basic peer-request-allowed event",
+    run: async function testPeerRequestEvent(browser) {
+      Events.on();
+
+      await tryPeerConnection(browser);
+
+      let details = Events.expect("peer-request-allowed");
+      isnot(
+        details.callID,
+        undefined,
+        "peer-request-allowed event includes callID"
+      );
+      isnot(
+        details.windowID,
+        undefined,
+        "peer-request-allowed event includes windowID"
+      );
+
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Immediate peer connection blocker can allow",
+    run: async function testBlocker(browser) {
+      Events.on();
+
+      let blockerCalled = false;
+      let blocker = params => {
+        is(
+          params.origin,
+          ORIGIN,
+          "Peer connection blocker origin parameter is correct"
+        );
+        blockerCalled = true;
+        return "allow";
+      };
+
+      webrtcUI.addPeerConnectionBlocker(blocker);
+
+      await tryPeerConnection(browser);
+      is(blockerCalled, true, "Blocker was called");
+      Events.expect("peer-request-allowed");
+
+      webrtcUI.removePeerConnectionBlocker(blocker);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Deferred peer connection blocker can allow",
+    run: async function testDeferredBlocker(browser) {
+      Events.on();
+
+      let blocker = params => Promise.resolve("allow");
+      webrtcUI.addPeerConnectionBlocker(blocker);
+
+      await tryPeerConnection(browser);
+      Events.expect("peer-request-allowed");
+
+      webrtcUI.removePeerConnectionBlocker(blocker);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Immediate peer connection blocker can deny",
+    run: async function testBlockerDeny(browser) {
+      Events.on();
+
+      let blocker = params => "deny";
+      webrtcUI.addPeerConnectionBlocker(blocker);
+
+      await tryPeerConnection(browser, "NotAllowedError");
+
+      Events.expect("peer-request-blocked");
+
+      webrtcUI.removePeerConnectionBlocker(blocker);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Multiple blockers work (both allow)",
+    run: async function testMultipleAllowBlockers(browser) {
+      Events.on();
+
+      let blocker1Called = false,
+        blocker1 = params => {
+          blocker1Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker1);
+
+      let blocker2Called = false,
+        blocker2 = params => {
+          blocker2Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker2);
+
+      await tryPeerConnection(browser);
+
+      Events.expect("peer-request-allowed");
+      ok(blocker1Called, "First blocker was called");
+      ok(blocker2Called, "Second blocker was called");
+
+      webrtcUI.removePeerConnectionBlocker(blocker1);
+      webrtcUI.removePeerConnectionBlocker(blocker2);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Multiple blockers work (allow then deny)",
+    run: async function testAllowDenyBlockers(browser) {
+      Events.on();
+
+      let blocker1Called = false,
+        blocker1 = params => {
+          blocker1Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker1);
+
+      let blocker2Called = false,
+        blocker2 = params => {
+          blocker2Called = true;
+          return "deny";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker2);
+
+      await tryPeerConnection(browser, "NotAllowedError");
+
+      Events.expect("peer-request-blocked");
+      ok(blocker1Called, "First blocker was called");
+      ok(blocker2Called, "Second blocker was called");
+
+      webrtcUI.removePeerConnectionBlocker(blocker1);
+      webrtcUI.removePeerConnectionBlocker(blocker2);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Multiple blockers work (deny first)",
+    run: async function testDenyAllowBlockers(browser) {
+      Events.on();
+
+      let blocker1Called = false,
+        blocker1 = params => {
+          blocker1Called = true;
+          return "deny";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker1);
+
+      let blocker2Called = false,
+        blocker2 = params => {
+          blocker2Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker2);
+
+      await tryPeerConnection(browser, "NotAllowedError");
+
+      Events.expect("peer-request-blocked");
+      ok(blocker1Called, "First blocker was called");
+      ok(
+        !blocker2Called,
+        "Peer connection blocker after a deny is not invoked"
+      );
+
+      webrtcUI.removePeerConnectionBlocker(blocker1);
+      webrtcUI.removePeerConnectionBlocker(blocker2);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Blockers may be removed",
+    run: async function testRemoveBlocker(browser) {
+      Events.on();
+
+      let blocker1Called = false,
+        blocker1 = params => {
+          blocker1Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker1);
+
+      let blocker2Called = false,
+        blocker2 = params => {
+          blocker2Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker2);
+      webrtcUI.removePeerConnectionBlocker(blocker1);
+
+      await tryPeerConnection(browser);
+
+      Events.expect("peer-request-allowed");
+
+      ok(!blocker1Called, "Removed peer connection blocker is not invoked");
+      ok(blocker2Called, "Second peer connection blocker was invoked");
+
+      webrtcUI.removePeerConnectionBlocker(blocker2);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Blocker that throws is ignored",
+    run: async function testBlockerThrows(browser) {
+      Events.on();
+      let blocker1Called = false,
+        blocker1 = params => {
+          blocker1Called = true;
+          throw new Error("kaboom");
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker1);
+
+      let blocker2Called = false,
+        blocker2 = params => {
+          blocker2Called = true;
+          return "allow";
+        };
+      webrtcUI.addPeerConnectionBlocker(blocker2);
+
+      await tryPeerConnection(browser);
+
+      Events.expect("peer-request-allowed");
+      ok(blocker1Called, "First blocker was invoked");
+      ok(blocker2Called, "Second blocker was invoked");
+
+      webrtcUI.removePeerConnectionBlocker(blocker1);
+      webrtcUI.removePeerConnectionBlocker(blocker2);
+      Events.off();
+    },
+  },
+
+  {
+    desc: "Cancel peer request",
+    run: async function testBlockerCancel(browser) {
+      let blocker,
+        blockerPromise = new Promise(resolve => {
+          blocker = params => {
+            resolve();
+            // defer indefinitely
+            return new Promise(innerResolve => {});
+          };
+        });
+      webrtcUI.addPeerConnectionBlocker(blocker);
+
+      await SpecialPowers.spawn(browser, [], async function () {
+        new content.RTCPeerConnection().createOffer({
+          offerToReceiveAudio: true,
+        });
+      });
+
+      await blockerPromise;
+
+      let eventPromise = new Promise(resolve => {
+        webrtcUI.on("peer-request-cancel", function listener(details) {
+          resolve(details);
+          webrtcUI.off("peer-request-cancel", listener);
+        });
+      });
+
+      await SpecialPowers.spawn(browser, [], async function () {
+        content.location.reload();
+      });
+
+      let details = await eventPromise;
+      isnot(
+        details.callID,
+        undefined,
+        "peer-request-cancel event includes callID"
+      );
+      is(
+        details.origin,
+        ORIGIN,
+        "peer-request-cancel event has correct origin"
+      );
+
+      webrtcUI.removePeerConnectionBlocker(blocker);
+    },
+  },
+];
+
+add_task(async function test() {
+  await runTests(gTests, {
+    skipObserverVerification: true,
+    cleanup() {
+      is(
+        webrtcUI.peerConnectionBlockers.size,
+        0,
+        "Peer connection blockers list is empty"
+      );
+    },
+  });
+});
diff --git a/browser/base/content/test/webrtc/get_user_media.html b/browser/base/content/test/webrtc/get_user_media.html
new file mode 100644
index 0000000000..8003785e14
--- /dev/null
+++ b/browser/base/content/test/webrtc/get_user_media.html
@@ -0,0 +1,124 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="message"></div>
+<script>
+// Specifies whether we are using fake streams to run this automation
+var useFakeStreams = true;
+try {
+  var audioDevice = SpecialPowers.getCharPref("media.audio_loopback_dev");
+  var videoDevice = SpecialPowers.getCharPref("media.video_loopback_dev");
+  dump("TEST DEVICES: Using media devices:\n");
+  dump("audio: " + audioDevice + "\nvideo: " + videoDevice + "\n");
+  useFakeStreams = false;
+} catch (e) {
+  dump("TEST DEVICES: No test devices found (in media.{audio,video}_loopback_dev, using fake streams.\n");
+  useFakeStreams = true;
+}
+
+function message(m) {
+  // eslint-disable-next-line no-unsanitized/property
+  document.getElementById("message").innerHTML += `${m}<br>`;
+  top.postMessage(m, "*");
+}
+
+var gStreams = [];
+var gVideoEvents = [];
+var gAudioEvents = [];
+
+async function requestDevice(aAudio, aVideo, aShare, aBadDevice = false) {
+  const opts = {video: aVideo, audio: aAudio};
+  if (aShare) {
+    opts.video = { mediaSource: aShare };
+    SpecialPowers.wrap(document).notifyUserGestureActivation();
+  }
+  if (useFakeStreams) {
+    opts.fake = true;
+  }
+
+  if (aVideo && aBadDevice) {
+    opts.video = {
+      deviceId: "bad device",
+    };
+    opts.fake = true;
+  }
+
+  if (aAudio && aBadDevice) {
+    opts.audio = {
+      deviceId: "bad device",
+    };
+    opts.fake = true;
+  }
+
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia(opts)
+    gStreams.push(stream);
+
+    const videoTrack = stream.getVideoTracks()[0];
+    if (videoTrack) {
+      for (const name of ["mute", "unmute", "ended"]) {
+        videoTrack.addEventListener(name, () => gVideoEvents.push(name));
+      }
+    }
+
+    const audioTrack = stream.getAudioTracks()[0];
+    if (audioTrack) {
+      for (const name of ["mute", "unmute", "ended"]) {
+        audioTrack.addEventListener(name, () => gAudioEvents.push(name));
+      }
+    }
+    message("ok");
+  } catch (err) {
+    message("error: " + err);
+  }
+}
+
+let selectedAudioOutputId;
+async function requestAudioOutput(options = {}) {
+  const audioOutputOptions = options.requestSameDevice && {
+    deviceId: selectedAudioOutputId,
+  };
+  SpecialPowers.wrap(document).notifyUserGestureActivation();
+  try {
+    ({ deviceId: selectedAudioOutputId } =
+     await navigator.mediaDevices.selectAudioOutput(audioOutputOptions));
+    message("ok");
+  } catch (err) {
+    message("error: " + err);
+  }
+}
+
+message("pending");
+
+function stopTracks(aKind) {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      if (track.kind == aKind) {
+        track.stop();
+        stream.removeTrack(track);
+      }
+    }
+  }
+  gStreams = gStreams.filter(s => !!s.getTracks().length);
+  if (aKind == "video") {
+    gVideoEvents = [];
+  } else if (aKind == "audio") {
+    gAudioEvents = [];
+  }
+}
+
+function closeStream() {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      track.stop();
+    }
+  }
+  gStreams = [];
+  gVideoEvents = [];
+  gAudioEvents = [];
+  message("closed");
+}
+</script>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/get_user_media2.html b/browser/base/content/test/webrtc/get_user_media2.html
new file mode 100644
index 0000000000..810b00d47b
--- /dev/null
+++ b/browser/base/content/test/webrtc/get_user_media2.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="message"></div>
+<script>
+// Specifies whether we are using fake streams to run this automation
+var useFakeStreams = true;
+try {
+  var audioDevice = SpecialPowers.getCharPref("media.audio_loopback_dev");
+  var videoDevice = SpecialPowers.getCharPref("media.video_loopback_dev");
+  dump("TEST DEVICES: Using media devices:\n");
+  dump("audio: " + audioDevice + "\nvideo: " + videoDevice + "\n");
+  useFakeStreams = false;
+} catch (e) {
+  dump("TEST DEVICES: No test devices found (in media.{audio,video}_loopback_dev, using fake streams.\n");
+  useFakeStreams = true;
+}
+
+function message(m) {
+  // eslint-disable-next-line no-unsanitized/property
+  document.getElementById("message").innerHTML += `${m}<br>`;
+  top.postMessage(m, "*");
+}
+
+var gStreams = [];
+var gVideoEvents = [];
+var gAudioEvents = [];
+
+async function requestDevice(aAudio, aVideo, aShare, aBadDevice = false) {
+  const opts = {video: aVideo, audio: aAudio};
+  if (aShare) {
+    opts.video = { mediaSource: aShare };
+  }
+  if (useFakeStreams) {
+    opts.fake = true;
+  }
+
+  if (aVideo && aBadDevice) {
+    opts.video = {
+      deviceId: "bad device",
+    };
+    opts.fake = true;
+  }
+
+  if (aAudio && aBadDevice) {
+    opts.audio = {
+      deviceId: "bad device",
+    };
+    opts.fake = true;
+  }
+
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia(opts)
+    gStreams.push(stream);
+
+    const videoTrack = stream.getVideoTracks()[0];
+    if (videoTrack) {
+      for (const name of ["mute", "unmute", "ended"]) {
+        videoTrack.addEventListener(name, () => gVideoEvents.push(name));
+      }
+    }
+
+    const audioTrack = stream.getAudioTracks()[0];
+    if (audioTrack) {
+      for (const name of ["mute", "unmute", "ended"]) {
+        audioTrack.addEventListener(name, () => gAudioEvents.push(name));
+      }
+    }
+    message("ok");
+  } catch (err) {
+    message("error: " + err);
+  }
+}
+message("pending");
+
+function stopTracks(aKind) {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      if (track.kind == aKind) {
+        track.stop();
+        stream.removeTrack(track);
+      }
+    }
+  }
+  gStreams = gStreams.filter(s => !!s.getTracks().length);
+  if (aKind == "video") {
+    gVideoEvents = [];
+  } else if (aKind == "audio") {
+    gAudioEvents = [];
+  }
+}
+
+function closeStream() {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      track.stop();
+    }
+  }
+  gStreams = [];
+  gVideoEvents = [];
+  gAudioEvents = [];
+  message("closed");
+}
+</script>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/get_user_media_in_frame.html b/browser/base/content/test/webrtc/get_user_media_in_frame.html
new file mode 100644
index 0000000000..5bffd9cb8c
--- /dev/null
+++ b/browser/base/content/test/webrtc/get_user_media_in_frame.html
@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="message"></div>
+<script>
+// Specifies whether we are using fake streams to run this automation
+var useFakeStreams = true;
+try {
+  var audioDevice = SpecialPowers.getCharPref("media.audio_loopback_dev");
+  var videoDevice = SpecialPowers.getCharPref("media.video_loopback_dev");
+  dump("TEST DEVICES: Using media devices:\n");
+  dump("audio: " + audioDevice + "\nvideo: " + videoDevice + "\n");
+  useFakeStreams = false;
+} catch (e) {
+  dump("TEST DEVICES: No test devices found (in media.{audio,video}_loopback_dev, using fake streams.\n");
+  useFakeStreams = true;
+}
+
+function message(m) {
+  // eslint-disable-next-line no-unsanitized/property
+  document.getElementById("message").innerHTML += `${m}<br>`;
+  window.top.postMessage(m, "*");
+}
+
+var gStreams = [];
+
+function requestDevice(aAudio, aVideo, aShare) {
+  var opts = {video: aVideo, audio: aAudio};
+  if (aShare) {
+    opts.video = { mediaSource: aShare };
+  } else if (useFakeStreams) {
+    opts.fake = true;
+  }
+
+  window.navigator.mediaDevices.getUserMedia(opts)
+    .then(stream => {
+      gStreams.push(stream);
+      message("ok");
+    }, err => message("error: " + err));
+}
+message("pending");
+
+function stopTracks(aKind) {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      if (track.kind == aKind) {
+        track.stop();
+        stream.removeTrack(track);
+      }
+    }
+  }
+  gStreams = gStreams.filter(s => !!s.getTracks().length);
+}
+
+function closeStream() {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      track.stop();
+    }
+  }
+  gStreams = [];
+  message("closed");
+}
+
+const query = document.location.search.substring(1);
+const params = new URLSearchParams(query);
+const origins = params.getAll("origin");
+const nested = params.getAll("nested");
+const gumpage = nested.length
+  ? "get_user_media_in_frame.html"
+  : "get_user_media.html";
+let id = 1;
+if (!origins.length) {
+  for(let i = 0; i < 2; ++i) {
+    const iframe = document.createElement("iframe");
+    iframe.id = `frame${id++}`;
+    iframe.src = gumpage;
+    document.body.appendChild(iframe);
+  }
+} else {
+  for (let origin of origins) {
+    const iframe = document.createElement("iframe");
+    iframe.id = `frame${id++}`;
+    const base = new URL("browser/browser/base/content/test/webrtc/", origin).href;
+    const url = new URL(gumpage, base);
+    for (let nestedOrigin of nested) {
+      url.searchParams.append("origin", nestedOrigin);
+    }
+    iframe.src = url.href;
+    iframe.allow = "camera;microphone";
+    iframe.style = `width:${300 * Math.max(1, nested.length) + (nested.length ? 50 : 0)}px;`;
+    document.body.appendChild(iframe);
+  }
+}
+</script>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame.html b/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame.html
new file mode 100644
index 0000000000..6a1c88cbe1
--- /dev/null
+++ b/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="message"></div>
+<script>
+// Specifies whether we are using fake streams to run this automation
+var useFakeStreams = true;
+try {
+  var audioDevice = SpecialPowers.getCharPref("media.audio_loopback_dev");
+  var videoDevice = SpecialPowers.getCharPref("media.video_loopback_dev");
+  dump("TEST DEVICES: Using media devices:\n");
+  dump("audio: " + audioDevice + "\nvideo: " + videoDevice + "\n");
+  useFakeStreams = false;
+} catch (e) {
+  dump("TEST DEVICES: No test devices found (in media.{audio,video}_loopback_dev, using fake streams.\n");
+  useFakeStreams = true;
+}
+
+function message(m) {
+  // eslint-disable-next-line no-unsanitized/property
+  document.getElementById("message").innerHTML += `${m}<br>`;
+  window.parent.postMessage(m, "*");
+}
+
+var gStreams = [];
+
+function requestDevice(aAudio, aVideo, aShare) {
+  var opts = {video: aVideo, audio: aAudio};
+  if (aShare) {
+    opts.video = { mediaSource: aShare };
+  } else if (useFakeStreams) {
+    opts.fake = true;
+  }
+
+  window.navigator.mediaDevices.getUserMedia(opts)
+    .then(stream => {
+      gStreams.push(stream);
+      message("ok");
+    }, err => message("error: " + err));
+}
+message("pending");
+
+function stopTracks(aKind) {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      if (track.kind == aKind) {
+        track.stop();
+        stream.removeTrack(track);
+      }
+    }
+  }
+  gStreams = gStreams.filter(s => !!s.getTracks().length);
+}
+
+function closeStream() {
+  for (let stream of gStreams) {
+    for (let track of stream.getTracks()) {
+      track.stop();
+    }
+  }
+  gStreams = [];
+  message("closed");
+}
+</script>
+<iframe id="frame1" allow="camera;microphone;display-capture" src="https://test1.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"></iframe>
+<iframe id="frame2" allow="camera;microphone" src="https://test1.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"></iframe>
+<iframe id="frame3" src="https://test1.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"></iframe>
+<iframe id="frame4" allow="camera *;microphone *;display-capture *" src="https://test1.example.com/browser/browser/base/content/test/webrtc/get_user_media.html"></iframe>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame_ancestor.html b/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame_ancestor.html
new file mode 100644
index 0000000000..bed446a7da
--- /dev/null
+++ b/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame_ancestor.html
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<title>Permissions Test</title>
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta>
+</head>
+<body>
+  <iframe id="frameAncestor"
+    src="https://test2.example.com/browser/browser/base/content/test/webrtc/get_user_media_in_xorigin_frame.html"
+    allow="camera 'src' https://test1.example.com;microphone 'src' https://test1.example.com;display-capture 'src' https://test1.example.com"></iframe>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/gracePeriod/browser.ini b/browser/base/content/test/webrtc/gracePeriod/browser.ini
new file mode 100644
index 0000000000..0f9503fe81
--- /dev/null
+++ b/browser/base/content/test/webrtc/gracePeriod/browser.ini
@@ -0,0 +1,15 @@
+[DEFAULT]
+support-files =
+  ../get_user_media.html
+  ../get_user_media_in_frame.html
+  ../get_user_media_in_xorigin_frame.html
+  ../get_user_media_in_xorigin_frame_ancestor.html
+  ../head.js
+prefs =
+  privacy.webrtc.allowSilencingNotifications=true
+  privacy.webrtc.legacyGlobalIndicator=false
+  privacy.webrtc.sharedTabWarning=false
+
+[../browser_devices_get_user_media_grace.js]
+skip-if =
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
diff --git a/browser/base/content/test/webrtc/head.js b/browser/base/content/test/webrtc/head.js
new file mode 100644
index 0000000000..13526e91b6
--- /dev/null
+++ b/browser/base/content/test/webrtc/head.js
@@ -0,0 +1,1338 @@
+var { PermissionTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PermissionTestUtils.sys.mjs"
+);
+
+const PREF_PERMISSION_FAKE = "media.navigator.permission.fake";
+const PREF_AUDIO_LOOPBACK = "media.audio_loopback_dev";
+const PREF_VIDEO_LOOPBACK = "media.video_loopback_dev";
+const PREF_FAKE_STREAMS = "media.navigator.streams.fake";
+const PREF_FOCUS_SOURCE = "media.getusermedia.window.focus_source.enabled";
+
+const STATE_CAPTURE_ENABLED = Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED;
+const STATE_CAPTURE_DISABLED = Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED;
+
+const USING_LEGACY_INDICATOR = Services.prefs.getBoolPref(
+  "privacy.webrtc.legacyGlobalIndicator",
+  false
+);
+
+const ALLOW_SILENCING_NOTIFICATIONS = Services.prefs.getBoolPref(
+  "privacy.webrtc.allowSilencingNotifications",
+  false
+);
+
+const SHOW_GLOBAL_MUTE_TOGGLES = Services.prefs.getBoolPref(
+  "privacy.webrtc.globalMuteToggles",
+  false
+);
+
+const INDICATOR_PATH = USING_LEGACY_INDICATOR
+  ? "chrome://browser/content/webrtcLegacyIndicator.xhtml"
+  : "chrome://browser/content/webrtcIndicator.xhtml";
+
+const IS_MAC = AppConstants.platform == "macosx";
+
+const SHARE_SCREEN = 1;
+const SHARE_WINDOW = 2;
+
+let observerTopics = [
+  "getUserMedia:response:allow",
+  "getUserMedia:revoke",
+  "getUserMedia:response:deny",
+  "getUserMedia:request",
+  "recording-device-events",
+  "recording-window-ended",
+];
+
+// Structured hierarchy of subframes. Keys are frame id:s, The children member
+// contains nested sub frames if any. The noTest member make a frame be ignored
+// for testing if true.
+let gObserveSubFrames = {};
+// Object of subframes to test. Each element contains the members bc and id, for
+// the frames BrowsingContext and id, respectively.
+let gSubFramesToTest = [];
+let gBrowserContextsToObserve = [];
+
+function whenDelayedStartupFinished(aWindow) {
+  return TestUtils.topicObserved(
+    "browser-delayed-startup-finished",
+    subject => subject == aWindow
+  );
+}
+
+function promiseIndicatorWindow() {
+  let startTime = performance.now();
+
+  // We don't show the legacy indicator window on Mac.
+  if (USING_LEGACY_INDICATOR && IS_MAC) {
+    return Promise.resolve();
+  }
+
+  return new Promise(resolve => {
+    Services.obs.addObserver(function obs(win) {
+      win.addEventListener(
+        "load",
+        function () {
+          if (win.location.href !== INDICATOR_PATH) {
+            info("ignoring a window with this url: " + win.location.href);
+            return;
+          }
+
+          Services.obs.removeObserver(obs, "domwindowopened");
+          executeSoon(() => {
+            ChromeUtils.addProfilerMarker("promiseIndicatorWindow", {
+              startTime,
+              category: "Test",
+            });
+            resolve(win);
+          });
+        },
+        { once: true }
+      );
+    }, "domwindowopened");
+  });
+}
+
+async function assertWebRTCIndicatorStatus(expected) {
+  let ui = ChromeUtils.import("resource:///modules/webrtcUI.jsm").webrtcUI;
+  let expectedState = expected ? "visible" : "hidden";
+  let msg = "WebRTC indicator " + expectedState;
+  if (!expected && ui.showGlobalIndicator) {
+    // It seems the global indicator is not always removed synchronously
+    // in some cases.
+    await TestUtils.waitForCondition(
+      () => !ui.showGlobalIndicator,
+      "waiting for the global indicator to be hidden"
+    );
+  }
+  is(ui.showGlobalIndicator, !!expected, msg);
+
+  let expectVideo = false,
+    expectAudio = false,
+    expectScreen = "";
+  if (expected) {
+    if (expected.video) {
+      expectVideo = true;
+    }
+    if (expected.audio) {
+      expectAudio = true;
+    }
+    if (expected.screen) {
+      expectScreen = expected.screen;
+    }
+  }
+  is(
+    Boolean(ui.showCameraIndicator),
+    expectVideo,
+    "camera global indicator as expected"
+  );
+  is(
+    Boolean(ui.showMicrophoneIndicator),
+    expectAudio,
+    "microphone global indicator as expected"
+  );
+  is(
+    ui.showScreenSharingIndicator,
+    expectScreen,
+    "screen global indicator as expected"
+  );
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    let menu = win.document.getElementById("tabSharingMenu");
+    is(
+      !!menu && !menu.hidden,
+      !!expected,
+      "WebRTC menu should be " + expectedState
+    );
+  }
+
+  if (USING_LEGACY_INDICATOR && IS_MAC) {
+    return;
+  }
+
+  if (!expected) {
+    let win = Services.wm.getMostRecentWindow("Browser:WebRTCGlobalIndicator");
+    if (win) {
+      await new Promise((resolve, reject) => {
+        win.addEventListener("unload", function listener(e) {
+          if (e.target == win.document) {
+            win.removeEventListener("unload", listener);
+            executeSoon(resolve);
+          }
+        });
+      });
+    }
+  }
+
+  let indicator = Services.wm.getEnumerator("Browser:WebRTCGlobalIndicator");
+  let hasWindow = indicator.hasMoreElements();
+  is(hasWindow, !!expected, "popup " + msg);
+  if (hasWindow) {
+    let document = indicator.getNext().document;
+    let docElt = document.documentElement;
+
+    if (document.readyState != "complete") {
+      info("Waiting for the sharing indicator's document to load");
+      await new Promise(resolve => {
+        document.addEventListener(
+          "readystatechange",
+          function onReadyStateChange() {
+            if (document.readyState != "complete") {
+              return;
+            }
+            document.removeEventListener(
+              "readystatechange",
+              onReadyStateChange
+            );
+            executeSoon(resolve);
+          }
+        );
+      });
+    }
+
+    if (
+      !USING_LEGACY_INDICATOR &&
+      expected.screen &&
+      expected.screen.startsWith("Window")
+    ) {
+      // These tests were originally written to express window sharing by
+      // having expected.screen start with "Window". This meant that the
+      // legacy indicator is expected to have the "sharingscreen" attribute
+      // set to true when sharing a window.
+      //
+      // The new indicator, however, differentiates between screen, window
+      // and browser window sharing. If we're using the new indicator, we
+      // update the expectations accordingly. This can be removed once we
+      // are able to remove the tests for the legacy indicator.
+      expected.screen = null;
+      expected.window = true;
+    }
+
+    if (!USING_LEGACY_INDICATOR && !SHOW_GLOBAL_MUTE_TOGGLES) {
+      expected.video = false;
+      expected.audio = false;
+
+      let visible = docElt.getAttribute("visible") == "true";
+
+      if (!expected.screen && !expected.window && !expected.browserwindow) {
+        ok(!visible, "Indicator should not be visible in this configuation.");
+      } else {
+        ok(visible, "Indicator should be visible.");
+      }
+    }
+
+    for (let item of ["video", "audio", "screen", "window", "browserwindow"]) {
+      let expectedValue;
+
+      if (USING_LEGACY_INDICATOR) {
+        expectedValue = expected && expected[item] ? "true" : "";
+      } else {
+        expectedValue = expected && expected[item] ? "true" : null;
+      }
+
+      is(
+        docElt.getAttribute("sharing" + item),
+        expectedValue,
+        item + " global indicator attribute as expected"
+      );
+    }
+
+    ok(!indicator.hasMoreElements(), "only one global indicator window");
+  }
+}
+
+function promiseNotificationShown(notification) {
+  let win = notification.browser.ownerGlobal;
+  if (win.PopupNotifications.panel.state == "open") {
+    return Promise.resolve();
+  }
+  let panelPromise = BrowserTestUtils.waitForPopupEvent(
+    win.PopupNotifications.panel,
+    "shown"
+  );
+  notification.reshow();
+  return panelPromise;
+}
+
+function ignoreEvent(aSubject, aTopic, aData) {
+  // With e10s disabled, our content script receives notifications for the
+  // preview displayed in our screen sharing permission prompt; ignore them.
+  const kBrowserURL = AppConstants.BROWSER_CHROME_URL;
+  const nsIPropertyBag = Ci.nsIPropertyBag;
+  if (
+    aTopic == "recording-device-events" &&
+    aSubject.QueryInterface(nsIPropertyBag).getProperty("requestURL") ==
+      kBrowserURL
+  ) {
+    return true;
+  }
+  if (aTopic == "recording-window-ended") {
+    let win = Services.wm.getOuterWindowWithId(aData).top;
+    if (win.document.documentURI == kBrowserURL) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function expectObserverCalledInProcess(aTopic, aCount = 1) {
+  let promises = [];
+  for (let count = aCount; count > 0; count--) {
+    promises.push(TestUtils.topicObserved(aTopic, ignoreEvent));
+  }
+  return promises;
+}
+
+function expectObserverCalled(
+  aTopic,
+  aCount = 1,
+  browser = gBrowser.selectedBrowser
+) {
+  if (!gMultiProcessBrowser) {
+    return expectObserverCalledInProcess(aTopic, aCount);
+  }
+
+  let browsingContext = Element.isInstance(browser)
+    ? browser.browsingContext
+    : browser;
+
+  return BrowserTestUtils.contentTopicObserved(browsingContext, aTopic, aCount);
+}
+
+// This is a special version of expectObserverCalled that should only
+// be used when expecting a notification upon closing a window. It uses
+// the per-process message manager instead of actors to send the
+// notifications.
+function expectObserverCalledOnClose(
+  aTopic,
+  aCount = 1,
+  browser = gBrowser.selectedBrowser
+) {
+  if (!gMultiProcessBrowser) {
+    return expectObserverCalledInProcess(aTopic, aCount);
+  }
+
+  let browsingContext = Element.isInstance(browser)
+    ? browser.browsingContext
+    : browser;
+
+  return new Promise(resolve => {
+    BrowserTestUtils.sendAsyncMessage(
+      browsingContext,
+      "BrowserTestUtils:ObserveTopic",
+      {
+        topic: aTopic,
+        count: 1,
+        filterFunctionSource: ((subject, topic, data) => {
+          Services.cpmm.sendAsyncMessage("WebRTCTest:ObserverCalled", {
+            topic,
+          });
+          return true;
+        }).toSource(),
+      }
+    );
+
+    function observerCalled(message) {
+      if (message.data.topic == aTopic) {
+        Services.ppmm.removeMessageListener(
+          "WebRTCTest:ObserverCalled",
+          observerCalled
+        );
+        resolve();
+      }
+    }
+    Services.ppmm.addMessageListener(
+      "WebRTCTest:ObserverCalled",
+      observerCalled
+    );
+  });
+}
+
+function promiseMessage(
+  aMessage,
+  aAction,
+  aCount = 1,
+  browser = gBrowser.selectedBrowser
+) {
+  let startTime = performance.now();
+  let promise = ContentTask.spawn(
+    browser,
+    [aMessage, aCount],
+    async function ([expectedMessage, expectedCount]) {
+      return new Promise(resolve => {
+        function listenForMessage({ data }) {
+          if (
+            (!expectedMessage || data == expectedMessage) &&
+            --expectedCount == 0
+          ) {
+            content.removeEventListener("message", listenForMessage);
+            resolve(data);
+          }
+        }
+        content.addEventListener("message", listenForMessage);
+      });
+    }
+  );
+  if (aAction) {
+    aAction();
+  }
+  return promise.then(data => {
+    ChromeUtils.addProfilerMarker(
+      "promiseMessage",
+      { startTime, category: "Test" },
+      data
+    );
+    return data;
+  });
+}
+
+function promisePopupNotificationShown(aName, aAction, aWindow = window) {
+  let startTime = performance.now();
+  return new Promise(resolve => {
+    aWindow.PopupNotifications.panel.addEventListener(
+      "popupshown",
+      function () {
+        ok(
+          !!aWindow.PopupNotifications.getNotification(aName),
+          aName + " notification shown"
+        );
+        ok(aWindow.PopupNotifications.isPanelOpen, "notification panel open");
+        ok(
+          !!aWindow.PopupNotifications.panel.firstElementChild,
+          "notification panel populated"
+        );
+
+        executeSoon(() => {
+          ChromeUtils.addProfilerMarker(
+            "promisePopupNotificationShown",
+            { startTime, category: "Test" },
+            aName
+          );
+          resolve();
+        });
+      },
+      { once: true }
+    );
+
+    if (aAction) {
+      aAction();
+    }
+  });
+}
+
+async function promisePopupNotification(aName) {
+  return TestUtils.waitForCondition(
+    () => PopupNotifications.getNotification(aName),
+    aName + " notification appeared"
+  );
+}
+
+async function promiseNoPopupNotification(aName) {
+  return TestUtils.waitForCondition(
+    () => !PopupNotifications.getNotification(aName),
+    aName + " notification removed"
+  );
+}
+
+const kActionAlways = 1;
+const kActionDeny = 2;
+const kActionNever = 3;
+
+async function activateSecondaryAction(aAction) {
+  let notification = PopupNotifications.panel.firstElementChild;
+  switch (aAction) {
+    case kActionNever:
+      if (notification.notification.secondaryActions.length > 1) {
+        // "Always Block" is the first (and only) item in the menupopup.
+        await Promise.all([
+          BrowserTestUtils.waitForEvent(notification.menupopup, "popupshown"),
+          notification.menubutton.click(),
+        ]);
+        notification.menupopup.querySelector("menuitem").click();
+        return;
+      }
+      if (!notification.checkbox.checked) {
+        notification.checkbox.click();
+      }
+    // fallthrough
+    case kActionDeny:
+      notification.secondaryButton.click();
+      break;
+    case kActionAlways:
+      if (!notification.checkbox.checked) {
+        notification.checkbox.click();
+      }
+      notification.button.click();
+      break;
+  }
+}
+
+async function getMediaCaptureState() {
+  let startTime = performance.now();
+
+  function gatherBrowsingContexts(aBrowsingContext) {
+    let list = [aBrowsingContext];
+
+    let children = aBrowsingContext.children;
+    for (let child of children) {
+      list.push(...gatherBrowsingContexts(child));
+    }
+
+    return list;
+  }
+
+  function combine(x, y) {
+    if (
+      x == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED ||
+      y == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED
+    ) {
+      return Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED;
+    }
+    if (
+      x == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED ||
+      y == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED
+    ) {
+      return Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED;
+    }
+    return Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+  }
+
+  let video = Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+  let audio = Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+  let screen = Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+  let window = Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+  let browser = Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+
+  for (let bc of gatherBrowsingContexts(
+    gBrowser.selectedBrowser.browsingContext
+  )) {
+    let state = await SpecialPowers.spawn(bc, [], async function () {
+      let mediaManagerService = Cc[
+        "@mozilla.org/mediaManagerService;1"
+      ].getService(Ci.nsIMediaManagerService);
+
+      let hasCamera = {};
+      let hasMicrophone = {};
+      let hasScreenShare = {};
+      let hasWindowShare = {};
+      let hasBrowserShare = {};
+      let devices = {};
+      mediaManagerService.mediaCaptureWindowState(
+        content,
+        hasCamera,
+        hasMicrophone,
+        hasScreenShare,
+        hasWindowShare,
+        hasBrowserShare,
+        devices,
+        false
+      );
+
+      return {
+        video: hasCamera.value,
+        audio: hasMicrophone.value,
+        screen: hasScreenShare.value,
+        window: hasWindowShare.value,
+        browser: hasBrowserShare.value,
+      };
+    });
+
+    video = combine(state.video, video);
+    audio = combine(state.audio, audio);
+    screen = combine(state.screen, screen);
+    window = combine(state.window, window);
+    browser = combine(state.browser, browser);
+  }
+
+  let result = {};
+
+  if (video != Ci.nsIMediaManagerService.STATE_NOCAPTURE) {
+    result.video = true;
+  }
+  if (audio != Ci.nsIMediaManagerService.STATE_NOCAPTURE) {
+    result.audio = true;
+  }
+
+  if (screen != Ci.nsIMediaManagerService.STATE_NOCAPTURE) {
+    result.screen = "Screen";
+  } else if (window != Ci.nsIMediaManagerService.STATE_NOCAPTURE) {
+    result.screen = "Window";
+  } else if (browser != Ci.nsIMediaManagerService.STATE_NOCAPTURE) {
+    result.screen = "Browser";
+  }
+
+  ChromeUtils.addProfilerMarker("getMediaCaptureState", {
+    startTime,
+    category: "Test",
+  });
+  return result;
+}
+
+async function stopSharing(
+  aType = "camera",
+  aShouldKeepSharing = false,
+  aFrameBC,
+  aWindow = window
+) {
+  let promiseRecordingEvent = expectObserverCalled(
+    "recording-device-events",
+    1,
+    aFrameBC
+  );
+  let observerPromise1 = expectObserverCalled(
+    "getUserMedia:revoke",
+    1,
+    aFrameBC
+  );
+
+  // If we are stopping screen sharing and expect to still have another stream,
+  // "recording-window-ended" won't be fired.
+  let observerPromise2 = null;
+  if (!aShouldKeepSharing) {
+    observerPromise2 = expectObserverCalled(
+      "recording-window-ended",
+      1,
+      aFrameBC
+    );
+  }
+
+  await revokePermission(aType, aShouldKeepSharing, aFrameBC, aWindow);
+  await promiseRecordingEvent;
+  await observerPromise1;
+  await observerPromise2;
+
+  if (!aShouldKeepSharing) {
+    await checkNotSharing();
+  }
+}
+
+async function revokePermission(
+  aType = "camera",
+  aShouldKeepSharing = false,
+  aFrameBC,
+  aWindow = window
+) {
+  aWindow.gPermissionPanel._identityPermissionBox.click();
+  let popup = aWindow.gPermissionPanel._permissionPopup;
+  // If the popup gets hidden before being shown, by stray focus/activate
+  // events, don't bother failing the test. It's enough to know that we
+  // started showing the popup.
+  let hiddenEvent = BrowserTestUtils.waitForEvent(popup, "popuphidden");
+  let shownEvent = BrowserTestUtils.waitForEvent(popup, "popupshown");
+  await Promise.race([hiddenEvent, shownEvent]);
+  let doc = aWindow.document;
+  let permissions = doc.getElementById("permission-popup-permission-list");
+  let cancelButton = permissions.querySelector(
+    ".permission-popup-permission-icon." +
+      aType +
+      "-icon ~ " +
+      ".permission-popup-permission-remove-button"
+  );
+
+  cancelButton.click();
+  popup.hidePopup();
+
+  if (!aShouldKeepSharing) {
+    await checkNotSharing();
+  }
+}
+
+function getBrowsingContextForFrame(aBrowsingContext, aFrameId) {
+  if (!aFrameId) {
+    return aBrowsingContext;
+  }
+
+  return SpecialPowers.spawn(aBrowsingContext, [aFrameId], frameId => {
+    return content.document.getElementById(frameId).browsingContext;
+  });
+}
+
+async function getBrowsingContextsAndFrameIdsForSubFrames(
+  aBrowsingContext,
+  aSubFrames
+) {
+  let pendingBrowserSubFrames = [
+    { bc: aBrowsingContext, subFrames: aSubFrames },
+  ];
+  let browsingContextsAndFrames = [];
+  while (pendingBrowserSubFrames.length) {
+    let { bc, subFrames } = pendingBrowserSubFrames.shift();
+    for (let id of Object.keys(subFrames)) {
+      let subBc = await getBrowsingContextForFrame(bc, id);
+      if (subFrames[id].children) {
+        pendingBrowserSubFrames.push({
+          bc: subBc,
+          subFrames: subFrames[id].children,
+        });
+      }
+      if (subFrames[id].noTest) {
+        continue;
+      }
+      let observeBC = subFrames[id].observe ? subBc : undefined;
+      browsingContextsAndFrames.push({ bc: subBc, id, observeBC });
+    }
+  }
+  return browsingContextsAndFrames;
+}
+
+async function promiseRequestDevice(
+  aRequestAudio,
+  aRequestVideo,
+  aFrameId,
+  aType,
+  aBrowsingContext,
+  aBadDevice = false
+) {
+  info("requesting devices");
+  let bc =
+    aBrowsingContext ??
+    (await getBrowsingContextForFrame(gBrowser.selectedBrowser, aFrameId));
+  return SpecialPowers.spawn(
+    bc,
+    [{ aRequestAudio, aRequestVideo, aType, aBadDevice }],
+    async function (args) {
+      let global = content.wrappedJSObject;
+      global.requestDevice(
+        args.aRequestAudio,
+        args.aRequestVideo,
+        args.aType,
+        args.aBadDevice
+      );
+    }
+  );
+}
+
+async function promiseRequestAudioOutput(options) {
+  info("requesting audio output");
+  const bc = gBrowser.selectedBrowser;
+  return SpecialPowers.spawn(bc, [options], async function (opts) {
+    const global = content.wrappedJSObject;
+    global.requestAudioOutput(Cu.cloneInto(opts, content));
+  });
+}
+
+async function stopTracks(
+  aKind,
+  aAlreadyStopped,
+  aLastTracks,
+  aFrameId,
+  aBrowsingContext,
+  aBrowsingContextToObserve
+) {
+  // If the observers are listening to other frames, listen for a notification
+  // on the right subframe.
+  let frameBC =
+    aBrowsingContext ??
+    (await getBrowsingContextForFrame(
+      gBrowser.selectedBrowser.browsingContext,
+      aFrameId
+    ));
+
+  let observerPromises = [];
+  if (!aAlreadyStopped) {
+    observerPromises.push(
+      expectObserverCalled(
+        "recording-device-events",
+        1,
+        aBrowsingContextToObserve
+      )
+    );
+  }
+  if (aLastTracks) {
+    observerPromises.push(
+      expectObserverCalled(
+        "recording-window-ended",
+        1,
+        aBrowsingContextToObserve
+      )
+    );
+  }
+
+  info(`Stopping all ${aKind} tracks`);
+  await SpecialPowers.spawn(frameBC, [aKind], async function (kind) {
+    content.wrappedJSObject.stopTracks(kind);
+  });
+
+  await Promise.all(observerPromises);
+}
+
+async function closeStream(
+  aAlreadyClosed,
+  aFrameId,
+  aDontFlushObserverVerification,
+  aBrowsingContext,
+  aBrowsingContextToObserve
+) {
+  // Check that spurious notifications that occur while closing the
+  // stream are handled separately. Tests that use skipObserverVerification
+  // should pass true for aDontFlushObserverVerification.
+  if (!aDontFlushObserverVerification) {
+    await disableObserverVerification();
+    await enableObserverVerification();
+  }
+
+  // If the observers are listening to other frames, listen for a notification
+  // on the right subframe.
+  let frameBC =
+    aBrowsingContext ??
+    (await getBrowsingContextForFrame(
+      gBrowser.selectedBrowser.browsingContext,
+      aFrameId
+    ));
+
+  let observerPromises = [];
+  if (!aAlreadyClosed) {
+    observerPromises.push(
+      expectObserverCalled(
+        "recording-device-events",
+        1,
+        aBrowsingContextToObserve
+      )
+    );
+    observerPromises.push(
+      expectObserverCalled(
+        "recording-window-ended",
+        1,
+        aBrowsingContextToObserve
+      )
+    );
+  }
+
+  info("closing the stream");
+  await SpecialPowers.spawn(frameBC, [], async function () {
+    content.wrappedJSObject.closeStream();
+  });
+
+  await Promise.all(observerPromises);
+
+  await assertWebRTCIndicatorStatus(null);
+}
+
+async function reloadAsUser() {
+  info("reloading as a user");
+
+  const reloadButton = document.getElementById("reload-button");
+  await TestUtils.waitForCondition(() => !reloadButton.disabled);
+  // Disable observers as the page is being reloaded which can destroy
+  // the actors listening to the notifications.
+  await disableObserverVerification();
+
+  let loadedPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+  reloadButton.click();
+  await loadedPromise;
+
+  await enableObserverVerification();
+}
+
+async function reloadFromContent() {
+  info("reloading from content");
+
+  // Disable observers as the page is being reloaded which can destroy
+  // the actors listening to the notifications.
+  await disableObserverVerification();
+
+  let loadedPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+  await ContentTask.spawn(gBrowser.selectedBrowser, null, () =>
+    content.location.reload()
+  );
+
+  await loadedPromise;
+
+  await enableObserverVerification();
+}
+
+async function reloadAndAssertClosedStreams() {
+  await reloadFromContent();
+  await checkNotSharing();
+}
+
+/**
+ * @param {("microphone"|"camera"|"screen")[]} aExpectedTypes
+ * @param {Window} [aWindow]
+ */
+function checkDeviceSelectors(aExpectedTypes, aWindow = window) {
+  for (const type of aExpectedTypes) {
+    if (!["microphone", "camera", "screen", "speaker"].includes(type)) {
+      throw new Error(`Bad device type name ${type}`);
+    }
+  }
+  let document = aWindow.document;
+
+  let expectedDescribedBy = "webRTC-shareDevices-notification-description";
+  for (let type of ["Camera", "Microphone", "Speaker"]) {
+    let selector = document.getElementById(`webRTC-select${type}`);
+    if (!aExpectedTypes.includes(type.toLowerCase())) {
+      ok(selector.hidden, `${type} selector hidden`);
+      continue;
+    }
+    ok(!selector.hidden, `${type} selector visible`);
+    let selectorList = document.getElementById(`webRTC-select${type}-menulist`);
+    let label = document.getElementById(
+      `webRTC-select${type}-single-device-label`
+    );
+    // If there's only 1 device listed, then we should show the label
+    // instead of the menulist.
+    if (selectorList.itemCount == 1) {
+      ok(selectorList.hidden, `${type} selector list should be hidden.`);
+      ok(!label.hidden, `${type} selector label should not be hidden.`);
+      is(
+        label.value,
+        selectorList.selectedItem.getAttribute("label"),
+        `${type} label should be showing the lone device label.`
+      );
+      expectedDescribedBy += ` webRTC-select${type}-icon webRTC-select${type}-single-device-label`;
+    } else {
+      ok(!selectorList.hidden, `${type} selector list should not be hidden.`);
+      ok(label.hidden, `${type} selector label should be hidden.`);
+    }
+  }
+  let ariaDescribedby =
+    aWindow.PopupNotifications.panel.getAttribute("aria-describedby");
+  is(ariaDescribedby, expectedDescribedBy, "aria-describedby");
+
+  let screenSelector = document.getElementById("webRTC-selectWindowOrScreen");
+  if (aExpectedTypes.includes("screen")) {
+    ok(!screenSelector.hidden, "screen selector visible");
+  } else {
+    ok(screenSelector.hidden, "screen selector hidden");
+  }
+}
+
+/**
+ * Tests the siteIdentity icons, the permission panel and the global indicator
+ * UI state.
+ * @param {Object} aExpected - Expected state for the current tab.
+ * @param {window} [aWin] - Top level chrome window to test state of.
+ * @param {Object} [aExpectedGlobal] - Expected state for all tabs.
+ * @param {Object} [aExpectedPerm] - Expected permission states keyed by device
+ * type.
+ */
+async function checkSharingUI(
+  aExpected,
+  aWin = window,
+  aExpectedGlobal = null,
+  aExpectedPerm = null
+) {
+  function isPaused(streamState) {
+    if (typeof streamState == "string") {
+      return streamState.includes("Paused");
+    }
+    return streamState == STATE_CAPTURE_DISABLED;
+  }
+
+  let doc = aWin.document;
+  // First check the icon above the control center (i) icon.
+  let permissionBox = doc.getElementById("identity-permission-box");
+  let webrtcSharingIcon = doc.getElementById("webrtc-sharing-icon");
+  ok(webrtcSharingIcon.hasAttribute("sharing"), "sharing attribute is set");
+  let sharing = webrtcSharingIcon.getAttribute("sharing");
+  if (aExpected.screen) {
+    is(sharing, "screen", "showing screen icon in the identity block");
+  } else if (aExpected.video == STATE_CAPTURE_ENABLED) {
+    is(sharing, "camera", "showing camera icon in the identity block");
+  } else if (aExpected.audio == STATE_CAPTURE_ENABLED) {
+    is(sharing, "microphone", "showing mic icon in the identity block");
+  } else if (aExpected.video) {
+    is(sharing, "camera", "showing camera icon in the identity block");
+  } else if (aExpected.audio) {
+    is(sharing, "microphone", "showing mic icon in the identity block");
+  }
+
+  let allStreamsPaused = Object.values(aExpected).every(isPaused);
+  is(
+    webrtcSharingIcon.hasAttribute("paused"),
+    allStreamsPaused,
+    "sharing icon(s) should be in paused state when paused"
+  );
+
+  // Then check the sharing indicators inside the permission popup.
+  permissionBox.click();
+  let popup = aWin.gPermissionPanel._permissionPopup;
+  // If the popup gets hidden before being shown, by stray focus/activate
+  // events, don't bother failing the test. It's enough to know that we
+  // started showing the popup.
+  let hiddenEvent = BrowserTestUtils.waitForEvent(popup, "popuphidden");
+  let shownEvent = BrowserTestUtils.waitForEvent(popup, "popupshown");
+  await Promise.race([hiddenEvent, shownEvent]);
+  let permissions = doc.getElementById("permission-popup-permission-list");
+  for (let id of ["microphone", "camera", "screen"]) {
+    let convertId = idToConvert => {
+      if (idToConvert == "camera") {
+        return "video";
+      }
+      if (idToConvert == "microphone") {
+        return "audio";
+      }
+      return idToConvert;
+    };
+    let expected = aExpected[convertId(id)];
+
+    // Extract the expected permission for the device type.
+    // Defaults to temporary allow.
+    let { state, scope } = aExpectedPerm?.[convertId(id)] || {};
+    if (state == null) {
+      state = SitePermissions.ALLOW;
+    }
+    if (scope == null) {
+      scope = SitePermissions.SCOPE_TEMPORARY;
+    }
+
+    is(
+      !!aWin.gPermissionPanel._sharingState.webRTC[id],
+      !!expected,
+      "sharing state for " + id + " as expected"
+    );
+    let item = permissions.querySelectorAll(
+      ".permission-popup-permission-item-" + id
+    );
+    let stateLabel = item?.[0]?.querySelector(
+      ".permission-popup-permission-state-label"
+    );
+    let icon = permissions.querySelectorAll(
+      ".permission-popup-permission-icon." + id + "-icon"
+    );
+    if (expected) {
+      is(item.length, 1, "should show " + id + " item in permission panel");
+      is(
+        stateLabel?.textContent,
+        SitePermissions.getCurrentStateLabel(state, id, scope),
+        "should show correct item label for " + id
+      );
+      is(icon.length, 1, "should show " + id + " icon in permission panel");
+      is(
+        icon[0].classList.contains("in-use"),
+        expected && !isPaused(expected),
+        "icon should have the in-use class, unless paused"
+      );
+    } else if (!icon.length && !item.length && !stateLabel) {
+      ok(true, "should not show " + id + " item in the permission panel");
+      ok(true, "should not show " + id + " icon in the permission panel");
+      ok(
+        true,
+        "should not show " + id + " state label in the permission panel"
+      );
+    } else {
+      // This will happen if there are persistent permissions set.
+      ok(
+        !icon[0].classList.contains("in-use"),
+        "if shown, the " + id + " icon should not have the in-use class"
+      );
+      is(item.length, 1, "should not show more than 1 " + id + " item");
+      is(icon.length, 1, "should not show more than 1 " + id + " icon");
+    }
+  }
+  aWin.gPermissionPanel._permissionPopup.hidePopup();
+  await TestUtils.waitForCondition(
+    () => permissionPopupHidden(aWin),
+    "identity popup should be hidden"
+  );
+
+  // Check the global indicators.
+  await assertWebRTCIndicatorStatus(aExpectedGlobal || aExpected);
+}
+
+async function checkNotSharing() {
+  Assert.deepEqual(
+    await getMediaCaptureState(),
+    {},
+    "expected nothing to be shared"
+  );
+
+  ok(
+    !document.getElementById("webrtc-sharing-icon").hasAttribute("sharing"),
+    "no sharing indicator on the control center icon"
+  );
+
+  await assertWebRTCIndicatorStatus(null);
+}
+
+async function checkNotSharingWithinGracePeriod() {
+  Assert.deepEqual(
+    await getMediaCaptureState(),
+    {},
+    "expected nothing to be shared"
+  );
+
+  ok(
+    document.getElementById("webrtc-sharing-icon").hasAttribute("sharing"),
+    "has sharing indicator on the control center icon"
+  );
+  ok(
+    document.getElementById("webrtc-sharing-icon").hasAttribute("paused"),
+    "sharing indicator is paused"
+  );
+
+  await assertWebRTCIndicatorStatus(null);
+}
+
+async function promiseReloadFrame(aFrameId, aBrowsingContext) {
+  let loadedPromise = BrowserTestUtils.browserLoaded(
+    gBrowser.selectedBrowser,
+    true,
+    arg => {
+      return true;
+    }
+  );
+  let bc =
+    aBrowsingContext ??
+    (await getBrowsingContextForFrame(
+      gBrowser.selectedBrowser.browsingContext,
+      aFrameId
+    ));
+  await SpecialPowers.spawn(bc, [], async function () {
+    content.location.reload();
+  });
+  return loadedPromise;
+}
+
+function promiseChangeLocationFrame(aFrameId, aNewLocation) {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser.browsingContext,
+    [{ aFrameId, aNewLocation }],
+    async function (args) {
+      let frame = content.wrappedJSObject.document.getElementById(
+        args.aFrameId
+      );
+      return new Promise(resolve => {
+        function listener() {
+          frame.removeEventListener("load", listener, true);
+          resolve();
+        }
+        frame.addEventListener("load", listener, true);
+
+        content.wrappedJSObject.document.getElementById(
+          args.aFrameId
+        ).contentWindow.location = args.aNewLocation;
+      });
+    }
+  );
+}
+
+async function openNewTestTab(leaf = "get_user_media.html") {
+  let rootDir = getRootDirectory(gTestPath);
+  rootDir = rootDir.replace(
+    "chrome://mochitests/content/",
+    "https://example.com/"
+  );
+  let absoluteURI = rootDir + leaf;
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, absoluteURI);
+  return tab.linkedBrowser;
+}
+
+// Enabling observer verification adds listeners for all of the webrtc
+// observer topics. If any notifications occur for those topics that
+// were not explicitly requested, a failure will occur.
+async function enableObserverVerification(browser = gBrowser.selectedBrowser) {
+  // Skip these checks in single process mode as it isn't worth implementing it.
+  if (!gMultiProcessBrowser) {
+    return;
+  }
+
+  gBrowserContextsToObserve = [browser.browsingContext];
+
+  // A list of subframe indicies to also add observers to. This only
+  // supports one nested level.
+  if (gObserveSubFrames) {
+    let bcsAndFrameIds = await getBrowsingContextsAndFrameIdsForSubFrames(
+      browser,
+      gObserveSubFrames
+    );
+    for (let { observeBC } of bcsAndFrameIds) {
+      if (observeBC) {
+        gBrowserContextsToObserve.push(observeBC);
+      }
+    }
+  }
+
+  for (let bc of gBrowserContextsToObserve) {
+    await BrowserTestUtils.startObservingTopics(bc, observerTopics);
+  }
+}
+
+async function disableObserverVerification() {
+  if (!gMultiProcessBrowser) {
+    return;
+  }
+
+  for (let bc of gBrowserContextsToObserve) {
+    await BrowserTestUtils.stopObservingTopics(bc, observerTopics).catch(
+      reason => {
+        ok(false, "Failed " + reason);
+      }
+    );
+  }
+}
+
+function permissionPopupHidden(win = window) {
+  let popup = win.gPermissionPanel._permissionPopup;
+  return !popup || popup.state == "closed";
+}
+
+async function runTests(tests, options = {}) {
+  let browser = await openNewTestTab(options.relativeURI);
+
+  is(
+    PopupNotifications._currentNotifications.length,
+    0,
+    "should start the test without any prior popup notification"
+  );
+  ok(
+    permissionPopupHidden(),
+    "should start the test with the permission panel hidden"
+  );
+
+  // Set prefs so that permissions prompts are shown and loopback devices
+  // are not used. To test the chrome we want prompts to be shown, and
+  // these tests are flakey when using loopback devices (though it would
+  // be desirable to make them work with loopback in future). See bug 1643711.
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+    [PREF_FOCUS_SOURCE, false],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+
+  // When the frames are in different processes, add observers to each frame,
+  // to ensure that the notifications don't get sent in the wrong process.
+  gObserveSubFrames = SpecialPowers.useRemoteSubframes ? options.subFrames : {};
+
+  for (let testCase of tests) {
+    let startTime = performance.now();
+    info(testCase.desc);
+    if (
+      !testCase.skipObserverVerification &&
+      !options.skipObserverVerification
+    ) {
+      await enableObserverVerification();
+    }
+    await testCase.run(browser, options.subFrames);
+    if (
+      !testCase.skipObserverVerification &&
+      !options.skipObserverVerification
+    ) {
+      await disableObserverVerification();
+    }
+    if (options.cleanup) {
+      await options.cleanup();
+    }
+    ChromeUtils.addProfilerMarker(
+      "browser-test",
+      { startTime, category: "Test" },
+      testCase.desc
+    );
+  }
+
+  // Some tests destroy the original tab and leave a new one in its place.
+  BrowserTestUtils.removeTab(gBrowser.selectedTab);
+}
+
+/**
+ * Given a browser from a tab in this window, chooses to share
+ * some combination of camera, mic or screen.
+ *
+ * @param {<xul:browser} browser - The browser to share devices with.
+ * @param {boolean} camera - True to share a camera device.
+ * @param {boolean} mic - True to share a microphone device.
+ * @param {Number} [screenOrWin] - One of either SHARE_WINDOW or SHARE_SCREEN
+ *   to share a window or screen. Defaults to neither.
+ * @param {boolean} remember - True to persist the permission to the
+ *   SitePermissions database as SitePermissions.SCOPE_PERSISTENT. Note that
+ *   callers are responsible for clearing this persistent permission.
+ * @return {Promise}
+ * @resolves {undefined} - Once the sharing is complete.
+ */
+async function shareDevices(
+  browser,
+  camera,
+  mic,
+  screenOrWin = 0,
+  remember = false
+) {
+  if (camera || mic) {
+    let promise = promisePopupNotificationShown(
+      "webRTC-shareDevices",
+      null,
+      window
+    );
+
+    await promiseRequestDevice(mic, camera, null, null, browser);
+    await promise;
+
+    const expectedDeviceSelectorTypes = [
+      camera && "camera",
+      mic && "microphone",
+    ].filter(x => x);
+    checkDeviceSelectors(expectedDeviceSelectorTypes);
+    let observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+    let observerPromise2 = expectObserverCalled("recording-device-events");
+
+    let rememberCheck = PopupNotifications.panel.querySelector(
+      ".popup-notification-checkbox"
+    );
+    rememberCheck.checked = remember;
+
+    promise = promiseMessage("ok", () => {
+      PopupNotifications.panel.firstElementChild.button.click();
+    });
+
+    await observerPromise1;
+    await observerPromise2;
+    await promise;
+  }
+
+  if (screenOrWin) {
+    let promise = promisePopupNotificationShown(
+      "webRTC-shareDevices",
+      null,
+      window
+    );
+
+    await promiseRequestDevice(false, true, null, "screen", browser);
+    await promise;
+
+    checkDeviceSelectors(["screen"], window);
+
+    let document = window.document;
+
+    let menulist = document.getElementById("webRTC-selectWindow-menulist");
+    let displayMediaSource;
+
+    if (screenOrWin == SHARE_SCREEN) {
+      displayMediaSource = "screen";
+    } else if (screenOrWin == SHARE_WINDOW) {
+      displayMediaSource = "window";
+    } else {
+      throw new Error("Got an invalid argument to shareDevices.");
+    }
+
+    let menuitem = null;
+    for (let i = 0; i < menulist.itemCount; ++i) {
+      let current = menulist.getItemAtIndex(i);
+      if (current.mediaSource == displayMediaSource) {
+        menuitem = current;
+        break;
+      }
+    }
+
+    Assert.ok(menuitem, "Should have found an appropriate display menuitem");
+    menuitem.doCommand();
+
+    let notification = window.PopupNotifications.panel.firstElementChild;
+
+    let observerPromise1 = expectObserverCalled("getUserMedia:response:allow");
+    let observerPromise2 = expectObserverCalled("recording-device-events");
+    await promiseMessage(
+      "ok",
+      () => {
+        notification.button.click();
+      },
+      1,
+      browser
+    );
+    await observerPromise1;
+    await observerPromise2;
+  }
+}
diff --git a/browser/base/content/test/webrtc/legacyIndicator/browser.ini b/browser/base/content/test/webrtc/legacyIndicator/browser.ini
new file mode 100644
index 0000000000..dc1c9e3104
--- /dev/null
+++ b/browser/base/content/test/webrtc/legacyIndicator/browser.ini
@@ -0,0 +1,63 @@
+[DEFAULT]
+support-files =
+  ../get_user_media.html
+  ../get_user_media_in_frame.html
+  ../get_user_media_in_xorigin_frame.html
+  ../get_user_media_in_xorigin_frame_ancestor.html
+  ../head.js
+prefs =
+  privacy.webrtc.allowSilencingNotifications=false
+  privacy.webrtc.legacyGlobalIndicator=true
+  privacy.webrtc.sharedTabWarning=false
+  privacy.webrtc.deviceGracePeriodTimeoutMs=0
+
+[../browser_devices_get_user_media.js]
+skip-if = 
+  (os == "linux") # linux: bug 976544, bug 1616011
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[../browser_devices_get_user_media_anim.js]
+skip-if =
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[../browser_devices_get_user_media_default_permissions.js]
+[../browser_devices_get_user_media_in_frame.js]
+skip-if = debug # bug 1369731
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[../browser_devices_get_user_media_in_xorigin_frame.js]
+skip-if =
+  debug # bug 1369731
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
+[../browser_devices_get_user_media_in_xorigin_frame_chain.js]
+[../browser_devices_get_user_media_multi_process.js]
+skip-if =
+  (debug && os == "win") # bug 1393761
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[../browser_devices_get_user_media_paused.js]
+skip-if =
+  (os == "win" && !debug) # Bug 1440900
+  (os =="linux" && !debug && bits == 64) # Bug 1440900
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+[../browser_devices_get_user_media_queue_request.js]
+skip-if =
+  os == "linux" # Bug 1775945
+  os == "win" && !debug # Bug 1775945
+[../browser_devices_get_user_media_screen.js]
+skip-if =
+  (os == 'linux') # Bug 1503991
+  apple_silicon   # bug 1707735
+  apple_catalina  # platform migration
+  os == "win"
+[../browser_devices_get_user_media_tear_off_tab.js]
+skip-if =
+  os == "linux" # Bug 1775945
+  os == "win" && !debug # Bug 1775945
+[../browser_devices_get_user_media_unprompted_access.js]
+skip-if = (os == "linux") # Bug 1712012
+[../browser_devices_get_user_media_unprompted_access_in_frame.js]
+[../browser_devices_get_user_media_unprompted_access_queue_request.js]
+[../browser_devices_get_user_media_unprompted_access_tear_off_tab.js]
+skip-if = (os == "win" && bits == 64) # win8: bug 1334752
+[../browser_webrtc_hooks.js]
diff --git a/browser/base/content/test/webrtc/peerconnection_connect.html b/browser/base/content/test/webrtc/peerconnection_connect.html
new file mode 100644
index 0000000000..5af6a4aafd
--- /dev/null
+++ b/browser/base/content/test/webrtc/peerconnection_connect.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="Page that opens a two peerconnections, and starts ICE"></div>
+<script>
+  const test = async () => {
+    const offerer = new RTCPeerConnection();
+    const answerer = new RTCPeerConnection();
+    offerer.addTransceiver('audio');
+
+    async function iceConnected(pc) {
+      return new Promise(r => {
+        if (pc.iceConnectionState == "connected") {
+          r();
+        }
+        pc.oniceconnectionstatechange = () => {
+          if (pc.iceConnectionState == "connected") {
+            r();
+          }
+        }
+      });
+    }
+
+    offerer.onicecandidate = e => answerer.addIceCandidate(e.candidate);
+    answerer.onicecandidate = e => offerer.addIceCandidate(e.candidate);
+    await offerer.setLocalDescription();
+    await answerer.setRemoteDescription(offerer.localDescription);
+    await answerer.setLocalDescription();
+    await offerer.setRemoteDescription(answerer.localDescription);
+    await iceConnected(offerer);
+    await iceConnected(answerer);
+    offerer.close();
+    answerer.close();
+  };
+  test();
+</script>
+</body>
+</html>
diff --git a/browser/base/content/test/webrtc/single_peerconnection.html b/browser/base/content/test/webrtc/single_peerconnection.html
new file mode 100644
index 0000000000..4b4432c51b
--- /dev/null
+++ b/browser/base/content/test/webrtc/single_peerconnection.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"></head>
+<body>
+<div id="Page that opens a single peerconnection"></div>
+<script>
+  let test = async () => {
+    let pc = new RTCPeerConnection();
+    pc.addTransceiver('audio');
+    pc.addTransceiver('video');
+    await pc.setLocalDescription();
+    await new Promise(r => {
+      pc.onicegatheringstatechange = () => {
+        if (pc.iceGatheringState == "complete") {
+          r();
+        }
+      };
+    });
+  };
+  test();
+</script>
+</body>
+</html>