Backed out 7 changesets (bug 1268749, bug 1270707, bug 1268750) a=bustage CLOSED TREE
authorWes Kocher <wkocher@mozilla.com>
Tue, 10 May 2016 14:53:15 -0700
changeset 326231 a32e6eb7b93f3553cb81f65a4272a635fd944b4a
parent 326230 39fce55feada79cade0a7f7b19f2f8cd75e69efb
child 326232 93227ba071585a31c3d25ffc5016eefc1c951420
push id1128
push userjlund@mozilla.com
push dateWed, 01 Jun 2016 01:31:59 +0000
treeherdermozilla-release@fe0d30de989d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbustage
bugs1268749, 1270707, 1268750
milestone47.0
backs out866d5e9827e4d06299fe4a5ff922fc72168bff05
1dd42a351054c5b697873d647169019d4d77d762
00f57fcfb86ee352e47657aa5074c6c8d0a3f0d4
13982d4d42e385a8517688896a5ab0144cb14982
599df73ed73fce0154940544f1e2ade233284e3d
795de3310aa3dc798c6ca3ab76869ab1cebc3484
618f026f5e41c7cdee61f87a3e96a5405ef1a60c
Backed out 7 changesets (bug 1268749, bug 1270707, bug 1268750) a=bustage CLOSED TREE Backed out changeset 866d5e9827e4 (bug 1268749) Backed out changeset 1dd42a351054 (bug 1270707) Backed out changeset 00f57fcfb86e (bug 1268749) Backed out changeset 13982d4d42e3 (bug 1268750) Backed out changeset 599df73ed73f (bug 1268749) Backed out changeset 795de3310aa3 (bug 1268749) Backed out changeset 618f026f5e41 (bug 1268749)
browser/modules/LaterRun.jsm
browser/modules/test/xpcshell/test_LaterRun.js
dom/base/nsContentUtils.cpp
dom/base/nsContentUtils.h
dom/base/nsDocument.cpp
dom/base/nsDocument.h
dom/events/EventListenerManager.cpp
dom/events/EventListenerManager.h
dom/html/test/file_fullscreen-unprefix-disabled-inner.html
dom/html/test/file_fullscreen-unprefix-disabled.html
dom/html/test/mochitest.ini
dom/html/test/test_fullscreen-api-race.html
dom/html/test/test_fullscreen-api.html
dom/tests/mochitest/pointerlock/test_pointerlock-api.html
dom/webidl/Document.webidl
dom/webidl/Element.webidl
dom/webidl/EventHandler.webidl
layout/inspector/inDOMUtils.cpp
layout/style/nsCSSParser.cpp
layout/style/nsCSSPseudoClassList.h
layout/style/nsCSSPseudoClasses.cpp
layout/style/nsCSSPseudoClasses.h
modules/libpref/init/all.js
--- a/browser/modules/LaterRun.jsm
+++ b/browser/modules/LaterRun.jsm
@@ -128,21 +128,19 @@ let LaterRun = {
       }
       pageDataStore.get(slug)[prop] = Preferences.get(pref, defaultPrefValue);
     }
     let rv = [];
     for (let [, pageData] of pageDataStore) {
       if (pageData.url) {
         let uri = null;
         try {
-          let urlString = Services.urlFormatter.formatURL(pageData.url.trim());
-          uri = Services.io.newURI(urlString, null, null);
+          uri = Services.io.newURI(pageData.url.trim(), null, null);
         } catch (ex) {
           Cu.reportError("Invalid LaterRun page URL " + pageData.url + " ignored.");
-          continue;
         }
         if (!uri.schemeIs("https")) {
           Cu.reportError("Insecure LaterRun page URL " + uri.spec + " ignored.");
         } else {
           pageData.url = uri.spec;
           rv.push(new Page(pageData));
         }
       }
--- a/browser/modules/test/xpcshell/test_LaterRun.js
+++ b/browser/modules/test/xpcshell/test_LaterRun.js
@@ -4,40 +4,33 @@ const kEnabledPref = "browser.laterrun.e
 const kPagePrefRoot = "browser.laterrun.pages.";
 const kSessionCountPref = "browser.laterrun.bookkeeping.sessionCount";
 const kProfileCreationTime = "browser.laterrun.bookkeeping.profileCreationTime";
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource:///modules/LaterRun.jsm");
 
 Services.prefs.setBoolPref(kEnabledPref, true);
-Components.utils.import("resource://testing-common/AppInfo.jsm");
-updateAppInfo();
 
 add_task(function* test_page_applies() {
-  Services.prefs.setCharPref(kPagePrefRoot + "test_LaterRun_unittest.url", "https://www.mozilla.org/%VENDOR%/%NAME%/%ID%/%VERSION%/");
+  Services.prefs.setCharPref(kPagePrefRoot + "test_LaterRun_unittest.url", "https://www.mozilla.org/");
   Services.prefs.setIntPref(kPagePrefRoot + "test_LaterRun_unittest.minimumHoursSinceInstall", 10);
   Services.prefs.setIntPref(kPagePrefRoot + "test_LaterRun_unittest.minimumSessionCount", 3);
 
   let pages = LaterRun.readPages();
   // We have to filter the pages because it's possible Firefox ships with other URLs
   // that get included in this test.
   pages = pages.filter(page => page.pref == kPagePrefRoot + "test_LaterRun_unittest.");
   Assert.equal(pages.length, 1, "Got 1 page");
   let page = pages[0];
   Assert.equal(page.pref, kPagePrefRoot + "test_LaterRun_unittest.", "Should know its own pref");
   Assert.equal(page.minimumHoursSinceInstall, 10, "Needs to have 10 hours since install");
   Assert.equal(page.minimumSessionCount, 3, "Needs to have 3 sessions");
   Assert.equal(page.requireBoth, false, "Either requirement is enough");
-  let expectedURL = "https://www.mozilla.org/" +
-    Services.appinfo.vendor + "/" +
-    Services.appinfo.name + "/" +
-    Services.appinfo.ID + "/" +
-    Services.appinfo.version + "/";
-  Assert.equal(page.url, expectedURL, "URL is stored correctly");
+  Assert.equal(page.url, "https://www.mozilla.org/", "URL is stored correctly");
 
   Assert.ok(page.applies({hoursSinceInstall: 1, sessionCount: 3}),
             "Applies when session count has been met.");
   Assert.ok(page.applies({hoursSinceInstall: 1, sessionCount: 4}),
             "Applies when session count has been exceeded.");
   Assert.ok(page.applies({hoursSinceInstall: 10, sessionCount: 2}),
             "Applies when total session time has been met.");
   Assert.ok(page.applies({hoursSinceInstall: 20, sessionCount: 2}),
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -258,17 +258,16 @@ nsString* nsContentUtils::sShiftText = n
 nsString* nsContentUtils::sControlText = nullptr;
 nsString* nsContentUtils::sMetaText = nullptr;
 nsString* nsContentUtils::sOSText = nullptr;
 nsString* nsContentUtils::sAltText = nullptr;
 nsString* nsContentUtils::sModifierSeparator = nullptr;
 
 bool nsContentUtils::sInitialized = false;
 bool nsContentUtils::sIsFullScreenApiEnabled = false;
-bool nsContentUtils::sIsUnprefixedFullscreenApiEnabled = false;
 bool nsContentUtils::sTrustedFullScreenOnly = true;
 bool nsContentUtils::sIsCutCopyAllowed = true;
 bool nsContentUtils::sIsFrameTimingPrefEnabled = false;
 bool nsContentUtils::sIsPerformanceTimingEnabled = false;
 bool nsContentUtils::sIsResourceTimingEnabled = false;
 bool nsContentUtils::sIsUserTimingLoggingEnabled = false;
 bool nsContentUtils::sIsExperimentalAutocompleteEnabled = false;
 bool nsContentUtils::sEncodeDecodeURLHash = false;
@@ -534,19 +533,16 @@ nsContentUtils::Init()
   sBlockedScriptRunners = new nsTArray< nsCOMPtr<nsIRunnable> >;
 
   Preferences::AddBoolVarCache(&sAllowXULXBL_for_file,
                                "dom.allow_XUL_XBL_for_file");
 
   Preferences::AddBoolVarCache(&sIsFullScreenApiEnabled,
                                "full-screen-api.enabled");
 
-  Preferences::AddBoolVarCache(&sIsUnprefixedFullscreenApiEnabled,
-                               "full-screen-api.unprefix.enabled");
-
   Preferences::AddBoolVarCache(&sTrustedFullScreenOnly,
                                "full-screen-api.allow-trusted-requests-only");
 
   Preferences::AddBoolVarCache(&sIsCutCopyAllowed,
                                "dom.allow_cut_copy", true);
 
   Preferences::AddBoolVarCache(&sIsPerformanceTimingEnabled,
                                "dom.enable_performance", true);
--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -1936,22 +1936,16 @@ public:
   static bool IsFocusedContent(const nsIContent *aContent);
 
   /**
    * Returns true if the DOM full-screen API is enabled.
    */
   static bool IsFullScreenApiEnabled();
 
   /**
-   * Returns true if the unprefixed fullscreen API is enabled.
-   */
-  static bool IsUnprefixedFullscreenApiEnabled()
-    { return sIsUnprefixedFullscreenApiEnabled; }
-
-  /**
    * Returns true if requests for full-screen are allowed in the current
    * context. Requests are only allowed if the user initiated them (like with
    * a mouse-click or key press), unless this check has been disabled by
    * setting the pref "full-screen-api.allow-trusted-requests-only" to false.
    */
   static bool IsRequestFullScreenAllowed();
 
   /**
@@ -2688,17 +2682,16 @@ private:
   static uint32_t sRunnersCountAtFirstBlocker;
   static uint32_t sScriptBlockerCountWhereRunnersPrevented;
 
   static nsIInterfaceRequestor* sSameOriginChecker;
 
   static bool sIsHandlingKeyBoardEvent;
   static bool sAllowXULXBL_for_file;
   static bool sIsFullScreenApiEnabled;
-  static bool sIsUnprefixedFullscreenApiEnabled;
   static bool sTrustedFullScreenOnly;
   static bool sIsCutCopyAllowed;
   static uint32_t sHandlingInputTimeout;
   static bool sIsPerformanceTimingEnabled;
   static bool sIsResourceTimingEnabled;
   static bool sIsUserTimingLoggingEnabled;
   static bool sIsFrameTimingPrefEnabled;
   static bool sIsExperimentalAutocompleteEnabled;
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -11649,24 +11649,16 @@ nsresult nsDocument::RemoteFrameFullscre
 }
 
 nsresult nsDocument::RemoteFrameFullscreenReverted()
 {
   RestorePreviousFullScreenState();
   return NS_OK;
 }
 
-/* static */ bool
-nsDocument::IsUnprefixedFullscreenEnabled(JSContext* aCx, JSObject* aObject)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  return nsContentUtils::IsCallerChrome() ||
-         nsContentUtils::IsUnprefixedFullscreenApiEnabled();
-}
-
 static void
 ReleaseVRDeviceProxyRef(void *, nsIAtom*, void *aPropertyValue, void *)
 {
   if (aPropertyValue) {
     static_cast<gfx::VRDeviceProxy*>(aPropertyValue)->Release();
   }
 }
 
--- a/dom/base/nsDocument.h
+++ b/dom/base/nsDocument.h
@@ -1230,18 +1230,16 @@ public:
   // Returns strong references to mBlockedTrackingNodes. (nsIDocument.h)
   //
   // This array contains nodes that have been blocked to prevent
   // user tracking. They most likely have had their nsIChannel
   // canceled by the URL classifier (Safebrowsing).
   //
   already_AddRefed<nsSimpleContentList> BlockedTrackingNodes() const;
 
-  static bool IsUnprefixedFullscreenEnabled(JSContext* aCx, JSObject* aObject);
-
   // Do the "fullscreen element ready check" from the fullscreen spec.
   // It returns true if the given element is allowed to go into fullscreen.
   bool FullscreenElementReadyCheck(Element* aElement, bool aWasCallerChrome);
 
   // This is called asynchronously by nsIDocument::AsyncRequestFullScreen()
   // to move this document into full-screen mode if allowed.
   void RequestFullScreen(mozilla::UniquePtr<FullscreenRequest>&& aRequest);
 
--- a/dom/events/EventListenerManager.cpp
+++ b/dom/events/EventListenerManager.cpp
@@ -279,18 +279,16 @@ EventListenerManager::AddEventListenerIn
   listener->mListener = aListenerHolder;
   listener->mEventMessage = aEventMessage;
   listener->mTypeString = aTypeString;
   listener->mTypeAtom = aTypeAtom;
   listener->mFlags = aFlags;
   listener->mListenerIsHandler = aHandler;
   listener->mHandlerIsString = false;
   listener->mAllEvents = aAllEvents;
-  listener->mIsChrome = mIsMainThreadELM &&
-    nsContentUtils::LegacyIsCallerChromeOrNativeCode();
 
   // Detect the type of event listener.
   nsCOMPtr<nsIXPConnectWrappedJS> wjs;
   if (aFlags.mListenerIsJSListener) {
     MOZ_ASSERT(!aListenerHolder.HasWebIDLCallback());
     listener->mListenerType = Listener::eJSEventListener;
   } else if (aListenerHolder.HasWebIDLCallback()) {
     listener->mListenerType = Listener::eWebIDLListener;
@@ -675,25 +673,16 @@ EventListenerManager::ListenerCanHandle(
     return true;
   }
   if (aEvent->mMessage == eUnidentifiedEvent) {
     if (mIsMainThreadELM) {
       return aListener->mTypeAtom == aEvent->userType;
     }
     return aListener->mTypeString.Equals(aEvent->typeString);
   }
-  if (!nsContentUtils::IsUnprefixedFullscreenApiEnabled() &&
-      aEvent->IsTrusted() && (aEventMessage == eFullscreenChange ||
-                              aEventMessage == eFullscreenError)) {
-    // If unprefixed Fullscreen API is not enabled, don't dispatch it
-    // to the content.
-    if (!aEvent->mFlags.mInSystemGroup && !aListener->mIsChrome) {
-      return false;
-    }
-  }
   MOZ_ASSERT(mIsMainThreadELM);
   return aListener->mEventMessage == aEventMessage;
 }
 
 void
 EventListenerManager::AddEventListenerByType(
                         const EventListenerHolder& aListenerHolder,
                         const nsAString& aType,
--- a/dom/events/EventListenerManager.h
+++ b/dom/events/EventListenerManager.h
@@ -190,17 +190,16 @@ public:
       eWebIDLListener,
       eListenerTypeCount
     };
     uint8_t mListenerType;
 
     bool mListenerIsHandler : 1;
     bool mHandlerIsString : 1;
     bool mAllEvents : 1;
-    bool mIsChrome : 1;
 
     EventListenerFlags mFlags;
 
     JSEventHandler* GetJSEventHandler() const
     {
       return (mListenerType == eJSEventListener) ?
         static_cast<JSEventHandler*>(mListener.GetXPCOMCallback()) :
         nullptr;
deleted file mode 100644
--- a/dom/html/test/file_fullscreen-unprefix-disabled-inner.html
+++ /dev/null
@@ -1,95 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <title>Test for Bug 1268749</title>
-  <script type="application/javascript" src="/tests/SimpleTest/EventUtils.js"></script>
-  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-</head>
-<body>
-  <div id="fullscreen"></div>
-<script>
-
-function ok(condition, msg) {
-  opener.opener.ok(condition, "[unprefix-disabled] " + msg);
-}
-
-function is(a, b, msg) {
-  opener.opener.is(a, b, "[unprefix-disabled] " + msg);
-}
-
-function info(msg) {
-  opener.opener.info("[unprefix-disabled] " + msg);
-}
-
-SimpleTest.requestFlakyTimeout(
-  "need to wait for a while to confirm no unexpected event is dispatched");
-
-let div = document.getElementById("fullscreen");
-let unattachedDiv = document.createElement('div');
-
-function begin() {
-  ok(!("requestFullscreen" in div), "No element.requestFullscreen");
-  ok(!("exitFullscreen" in document), "No document.exitFullscreen");
-  ok(!("fullscreenElement" in document), "No document.fullscreenElement");
-  ok(!("fullscreenEnabled" in document), "No document.fullscreenEnabled");
-  ok(!("onfullscreenchange" in document), "No document.onfullscreenchange");
-  ok(!("onfullscreenerror" in document), "No document.onfullscreenerror");
-
-  for (var event of ["fullscreenchange", "fullscreenerror"]) {
-    let customEvent = new Event(event, {bubbles: true});
-    let gotCustomEventFromWindow = false;
-    let gotCustomEventFromDocument = false;
-    let listenerForWindow = evt => {
-      ok(!gotCustomEventFromWindow,
-         "Should get custom event from window only once");
-      ok(evt == customEvent, "Should get the desired custom event");
-      gotCustomEventFromWindow = true;
-    };
-    let listenerForDocument = evt => {
-      ok(!gotCustomEventFromDocument,
-         "Should get custom event from document only once");
-      ok(evt == customEvent, "Should get the desired custom event");
-      gotCustomEventFromDocument = true;
-    };
-    window.addEventListener(event, listenerForWindow);
-    document.addEventListener(event, listenerForDocument);
-    document.dispatchEvent(customEvent);
-    ok(gotCustomEventFromWindow, "Should get the custom event from window");
-    ok(gotCustomEventFromDocument, "Should get the custom event from document");
-    window.removeEventListener(event, listenerForWindow);
-    document.removeEventListener(event, listenerForDocument);
-
-    for (var target of [window, document]) {
-      target.addEventListener(event, () => {
-        ok(false, `No ${event} should be triggered on ${target}`);
-      });
-    }
-  }
-
-  document.addEventListener("mozfullscreenchange", enteredFullscreen);
-  SimpleTest.executeSoon(() => div.mozRequestFullScreen());
-}
-
-function enteredFullscreen() {
-  document.removeEventListener("mozfullscreenchange", enteredFullscreen);
-  document.addEventListener("mozfullscreenchange", exitedFullscreen);
-  SimpleTest.executeSoon(() => document.mozCancelFullScreen());
-}
-
-function exitedFullscreen() {
-  document.removeEventListener("mozfullscreenchange", exitedFullscreen);
-  document.addEventListener("mozfullscreenerror", errorFullscreen);
-  SimpleTest.executeSoon(() => unattachedDiv.mozRequestFullScreen());
-}
-
-function errorFullscreen() {
-  document.removeEventListener("mozfullscreenerror", errorFullscreen);
-  // Wait a short time before exiting this test to confirm that there is
-  // really no unwanted event gets dispatched.
-  setTimeout(() => opener.finish(), 200);
-}
-
-</script>
-</body>
-</html>
deleted file mode 100644
--- a/dom/html/test/file_fullscreen-unprefix-disabled.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <title>Test for Bug 1268749</title>
-  <script type="application/javascript" src="/tests/SimpleTest/EventUtils.js"></script>
-  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-</head>
-<body>
-<script>
-
-var gWindow = null;
-
-function begin() {
-  SpecialPowers.pushPrefEnv({
-    "set": [["full-screen-api.unprefix.enabled", false]]
-  }, () => {
-    gWindow = window.open("file_fullscreen-unprefix-disabled-inner.html",
-                          "", "width=500,height=500");
-    gWindow.addEventListener("load", () => {
-      gWindow.focus();
-      SimpleTest.waitForFocus(() => gWindow.begin(), gWindow);
-    });
-  });
-}
-
-function finish() {
-  gWindow.close();
-  SpecialPowers.popPrefEnv(opener.nextTest);
-}
-
-</script>
-</body>
-</html>
--- a/dom/html/test/mochitest.ini
+++ b/dom/html/test/mochitest.ini
@@ -59,18 +59,16 @@ support-files =
   file_fullscreen-nested.html
   file_fullscreen-prefixed.html
   file_fullscreen-plugins.html
   file_fullscreen-rollback.html
   file_fullscreen-scrollbar.html
   file_fullscreen-selector.html
   file_fullscreen-svg-element.html
   file_fullscreen-top-layer.html
-  file_fullscreen-unprefix-disabled-inner.html
-  file_fullscreen-unprefix-disabled.html
   file_fullscreen-utils.js
   file_iframe_sandbox_a_if1.html
   file_iframe_sandbox_a_if10.html
   file_iframe_sandbox_a_if11.html
   file_iframe_sandbox_a_if12.html
   file_iframe_sandbox_a_if13.html
   file_iframe_sandbox_a_if14.html
   file_iframe_sandbox_a_if15.html
--- a/dom/html/test/test_fullscreen-api-race.html
+++ b/dom/html/test/test_fullscreen-api-race.html
@@ -22,20 +22,17 @@ SimpleTest.waitForExplicitFinish();
 // and in real life, requestFullscreen can only be called inside a user
 // event handler. But we want to fix this race condition at some point,
 // via queuing all exiting request as well as entering request together
 // which we may eventually need to do for bug 1188256.
 SimpleTest.requestFlakyTimeout(
   "Need to wait for potential fullscreen transition");
 addLoadEvent(function () {
   SpecialPowers.pushPrefEnv({
-    "set": [
-      ["full-screen-api.unprefix.enabled", true],
-      ["full-screen-api.allow-trusted-requests-only", false]
-    ]
+    "set": [["full-screen-api.allow-trusted-requests-only", false]]
   }, next);
 });
 
 const OPEN_WINDOW_FUNCS = [
   function openNewTab() {
     return window.open("about:blank");
   },
   function openNewWindow() {
--- a/dom/html/test/test_fullscreen-api.html
+++ b/dom/html/test/test_fullscreen-api.html
@@ -39,17 +39,16 @@ var gTestWindows = [
   "file_fullscreen-svg-element.html",
   "file_fullscreen-navigation.html",
   "file_fullscreen-scrollbar.html",
   "file_fullscreen-selector.html",
   "file_fullscreen-top-layer.html",
   "file_fullscreen-backdrop.html",
   "file_fullscreen-nested.html",
   "file_fullscreen-prefixed.html",
-  "file_fullscreen-unprefix-disabled.html",
 ];
 
 var testWindow = null;
 var gTestIndex = 0;
 
 function finish() {
   SimpleTest.finish();
 }
@@ -88,17 +87,16 @@ try {
 is(window.fullScreen, false, "Shouldn't be able to set window fullscreen from content");
 // Ensure the full-screen api is enabled, and will be disabled on test exit.
 // Disable the requirement for trusted contexts only, so the tests are easier
 // to write
 addLoadEvent(function() {
   SpecialPowers.pushPrefEnv({
       "set": [
         ["full-screen-api.enabled", true],
-        ["full-screen-api.unprefix.enabled", true],
         ["full-screen-api.allow-trusted-requests-only", false],
         ["full-screen-api.transition-duration.enter", "0 0"],
         ["full-screen-api.transition-duration.leave", "0 0"]
       ]}, nextTest);
 });
 SimpleTest.waitForExplicitFinish();
 </script>
 </pre>
--- a/dom/tests/mochitest/pointerlock/test_pointerlock-api.html
+++ b/dom/tests/mochitest/pointerlock/test_pointerlock-api.html
@@ -25,17 +25,16 @@ https://bugzilla.mozilla.org/show_bug.cg
          * around this, all tests are run in a child window, which can go fullscreen.
          * This method is borrowed from dom/html/test/test_fullscreen-api.html.
          **/
 
         SimpleTest.waitForExplicitFinish();
 
         SpecialPowers.pushPrefEnv({"set": [
           ["full-screen-api.enabled", true],
-          ["full-screen-api.unprefix.enabled", true],
           ["full-screen-api.allow-trusted-requests-only", false],
           ["full-screen-api.transition-duration.enter", "0 0"],
           ["full-screen-api.transition-duration.leave", "0 0"]
         ]}, nextTest);
 
         // Run the tests which go full-screen in new window, as Mochitests
         // normally run in an iframe, which by default will not have the
         // allowfullscreen attribute set, so full-screen won't work.
--- a/dom/webidl/Document.webidl
+++ b/dom/webidl/Document.webidl
@@ -219,26 +219,23 @@ partial interface Document {
   readonly attribute unsigned long referrerPolicy;
 
 };
 
 // https://fullscreen.spec.whatwg.org/#api
 partial interface Document {
   // Note: Per spec the 'S' in these two is lowercase, but the "Moz"
   // versions hve it uppercase.
-  [Func="nsDocument::IsUnprefixedFullscreenEnabled"]
   readonly attribute boolean fullscreenEnabled;
   [BinaryName="fullscreenEnabled", Deprecated="PrefixedFullscreenAPI"]
   readonly attribute boolean mozFullScreenEnabled;
-  [Func="nsDocument::IsUnprefixedFullscreenEnabled"]
   readonly attribute Element? fullscreenElement;
   [BinaryName="fullscreenElement", Deprecated="PrefixedFullscreenAPI"]
   readonly attribute Element? mozFullScreenElement;
 
-  [Func="nsDocument::IsUnprefixedFullscreenEnabled"]
   void exitFullscreen();
   [BinaryName="exitFullscreen", Deprecated="PrefixedFullscreenAPI"]
   void mozCancelFullScreen();
 
   // Gecko-specific fullscreen bits
   [Deprecated="PrefixedFullscreenAPI"]
   readonly attribute boolean mozFullScreen;
 };
--- a/dom/webidl/Element.webidl
+++ b/dom/webidl/Element.webidl
@@ -249,13 +249,13 @@ dictionary RequestFullscreenOptions {
 };
 
 // https://fullscreen.spec.whatwg.org/#api
 partial interface Element {
   /**
    * The options parameter is non-standard. In Gecko, it can be:
    *  a RequestFullscreenOptions object
    */
-  [Throws, UnsafeInPrerendering, Func="nsDocument::IsUnprefixedFullscreenEnabled"]
+  [Throws, UnsafeInPrerendering]
   void requestFullscreen(optional any options);
   [Throws, UnsafeInPrerendering, BinaryName="requestFullscreen", Deprecated="PrefixedFullscreenAPI"]
   void mozRequestFullScreen(optional any options);
 };
--- a/dom/webidl/EventHandler.webidl
+++ b/dom/webidl/EventHandler.webidl
@@ -110,19 +110,17 @@ interface GlobalEventHandlers {
            [Pref="dom.w3c_pointer_events.enabled"]
            attribute EventHandler onpointerleave;
            [Pref="dom.w3c_pointer_events.enabled"]
            attribute EventHandler ongotpointercapture;
            [Pref="dom.w3c_pointer_events.enabled"]
            attribute EventHandler onlostpointercapture;
 
            // Fullscreen events handlers
-           [Func="nsDocument::IsUnprefixedFullscreenEnabled"]
            attribute EventHandler onfullscreenchange;
-           [Func="nsDocument::IsUnprefixedFullscreenEnabled"]
            attribute EventHandler onfullscreenerror;
            attribute EventHandler onmozfullscreenchange;
            attribute EventHandler onmozfullscreenerror;
 
            // Mozilla-specific handlers
            attribute EventHandler onmozpointerlockchange;
            attribute EventHandler onmozpointerlockerror;
 };
--- a/layout/inspector/inDOMUtils.cpp
+++ b/layout/inspector/inDOMUtils.cpp
@@ -1199,26 +1199,26 @@ GetStatesForPseudoClass(const nsAString&
     EventStates(),
     EventStates()
   };
   static_assert(MOZ_ARRAY_LENGTH(sPseudoClassStates) ==
                 nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1,
                 "Length of PseudoClassStates array is incorrect");
 
   nsCOMPtr<nsIAtom> atom = do_GetAtom(aStatePseudo);
-  nsCSSPseudoClasses::Type type = nsCSSPseudoClasses::GetPseudoType(atom, true, true);
 
   // Ignore :moz-any-link so we don't give the element simultaneous
   // visited and unvisited style state
-  if (type == nsCSSPseudoClasses::ePseudoClass_mozAnyLink) {
+  if (nsCSSPseudoClasses::GetPseudoType(atom) ==
+      nsCSSPseudoClasses::ePseudoClass_mozAnyLink) {
     return EventStates();
   }
   // Our array above is long enough that indexing into it with
   // NotPseudoClass is ok.
-  return sPseudoClassStates[static_cast<size_t>(type)];
+  return sPseudoClassStates[nsCSSPseudoClasses::GetPseudoType(atom)];
 }
 
 NS_IMETHODIMP
 inDOMUtils::GetCSSPseudoElementNames(uint32_t* aLength, char16_t*** aNames)
 {
   nsTArray<nsIAtom*> array;
 
   const CSSPseudoElementTypeBase pseudoCount =
--- a/layout/style/nsCSSParser.cpp
+++ b/layout/style/nsCSSParser.cpp
@@ -5867,24 +5867,29 @@ CSSParserImpl::ParsePseudoSelector(int32
   nsContentUtils::ASCIIToLower(buffer);
   nsCOMPtr<nsIAtom> pseudo = do_GetAtom(buffer);
 
   // stash away some info about this pseudo so we only have to get it once.
   bool isTreePseudo = false;
   CSSPseudoElementType pseudoElementType =
     nsCSSPseudoElements::GetPseudoType(pseudo);
   nsCSSPseudoClasses::Type pseudoClassType =
-    nsCSSPseudoClasses::GetPseudoType(pseudo, AgentRulesEnabled(),
-                                      ChromeRulesEnabled());
+    nsCSSPseudoClasses::GetPseudoType(pseudo);
   bool pseudoClassIsUserAction =
     nsCSSPseudoClasses::IsUserActionPseudoClass(pseudoClassType);
 
-  if (pseudoElementType < CSSPseudoElementType::Count && !AgentRulesEnabled() &&
-      nsCSSPseudoElements::PseudoElementIsUASheetOnly(pseudoElementType)) {
-    // This pseudo-element is not exposed to content.
+  if (!AgentRulesEnabled() &&
+      ((pseudoElementType < CSSPseudoElementType::Count &&
+        nsCSSPseudoElements::PseudoElementIsUASheetOnly(pseudoElementType)) ||
+       (pseudoClassType != nsCSSPseudoClasses::ePseudoClass_NotPseudoClass &&
+        nsCSSPseudoClasses::PseudoClassIsUASheetOnly(pseudoClassType)) ||
+       (!ChromeRulesEnabled() &&
+        (pseudoClassType != nsCSSPseudoClasses::ePseudoClass_NotPseudoClass &&
+         nsCSSPseudoClasses::PseudoClassIsUASheetAndChromeOnly(pseudoClassType))))) {
+    // This pseudo-element or pseudo-class is not exposed to content.
     REPORT_UNEXPECTED_TOKEN(PEPseudoSelUnknown);
     UngetToken();
     return eSelectorParsingStatus_Error;
   }
 
   // We currently allow :-moz-placeholder and ::-moz-placeholder. We have to
   // be a bit stricter regarding the pseudo-element parsing rules.
   if (pseudoElementType == CSSPseudoElementType::mozPlaceholder &&
--- a/layout/style/nsCSSPseudoClassList.h
+++ b/layout/style/nsCSSPseudoClassList.h
@@ -92,17 +92,17 @@ CSS_PSEUDO_CLASS(mozIsHTML, ":-moz-is-ht
 
 // Match all custom elements whose created callback has not yet been invoked
  CSS_STATE_PSEUDO_CLASS(unresolved, ":unresolved", 0, "", NS_EVENT_STATE_UNRESOLVED)
 
 // Matches nodes that are in a native-anonymous subtree (i.e., nodes in
 // a subtree of C++ anonymous content constructed by Gecko for its own
 // purposes).
 CSS_PSEUDO_CLASS(mozNativeAnonymous, ":-moz-native-anonymous",
-                 CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS, "")
+                 CSS_PSEUDO_CLASS_UA_SHEET_ONLY, "")
 
 // Matches anything when the specified look-and-feel metric is set
 CSS_PSEUDO_CLASS(mozSystemMetric, ":-moz-system-metric", 0, "")
 
 // -moz-locale-dir(ltr) and -moz-locale-dir(rtl) may be used
 // to match based on the locale's chrome direction
 CSS_PSEUDO_CLASS(mozLocaleDir, ":-moz-locale-dir", 0, "")
 
@@ -119,17 +119,17 @@ CSS_PSEUDO_CLASS(mozLWThemeDarkText, ":-
 CSS_PSEUDO_CLASS(mozWindowInactive, ":-moz-window-inactive", 0, "")
 
 // Matches any table elements that have a nonzero border attribute,
 // according to HTML integer attribute parsing rules.
 CSS_PSEUDO_CLASS(mozTableBorderNonzero, ":-moz-table-border-nonzero", 0, "")
 
 // Matches HTML frame/iframe elements which are mozbrowser.
 CSS_PSEUDO_CLASS(mozBrowserFrame, ":-moz-browser-frame",
-                 CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "")
+                 CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "")
 
 // Matches whatever the contextual reference elements are for the
 // matching operation.
 CSS_PSEUDO_CLASS(scope, ":scope", 0, "layout.css.scope-pseudo.enabled")
 
 // :not needs to come at the end of the non-bit pseudo-class list, since
 // it doesn't actually get directly matched on in SelectorMatches.
 CSS_PSEUDO_CLASS(notPseudo, ":not", 0, "")
@@ -156,62 +156,59 @@ CSS_STATE_PSEUDO_CLASS(target, ":target"
 CSS_STATE_PSEUDO_CLASS(indeterminate, ":indeterminate", 0, "",
                        NS_EVENT_STATE_INDETERMINATE)
 
 CSS_STATE_PSEUDO_CLASS(mozDevtoolsHighlighted, ":-moz-devtools-highlighted", 0, "",
                        NS_EVENT_STATE_DEVTOOLS_HIGHLIGHTED)
 
 // Matches the element which is being displayed full-screen, and
 // any containing frames.
-CSS_STATE_PSEUDO_CLASS(fullscreen, ":fullscreen",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME,
-                       "full-screen-api.unprefix.enabled",
-                       NS_EVENT_STATE_FULL_SCREEN)
+CSS_STATE_PSEUDO_CLASS(fullscreen, ":fullscreen", 0, "", NS_EVENT_STATE_FULL_SCREEN)
 CSS_STATE_PSEUDO_CLASS(mozFullScreen, ":-moz-full-screen", 0, "", NS_EVENT_STATE_FULL_SCREEN)
 
 // Matches any element which is an ancestor of the DOM full-screen element,
 // or an ancestor of a containing frame of the full-screen element.
 CSS_STATE_PSEUDO_CLASS(mozFullScreenAncestor, ":-moz-full-screen-ancestor", 0, "", NS_EVENT_STATE_FULL_SCREEN_ANCESTOR)
 
 // Matches if the element is focused and should show a focus ring
 CSS_STATE_PSEUDO_CLASS(mozFocusRing, ":-moz-focusring", 0, "", NS_EVENT_STATE_FOCUSRING)
 
 // Image, object, etc state pseudo-classes
 CSS_STATE_PSEUDO_CLASS(mozBroken, ":-moz-broken", 0, "", NS_EVENT_STATE_BROKEN)
 CSS_STATE_PSEUDO_CLASS(mozLoading, ":-moz-loading", 0, "", NS_EVENT_STATE_LOADING)
 
 CSS_STATE_PSEUDO_CLASS(mozUserDisabled, ":-moz-user-disabled",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_USERDISABLED)
 CSS_STATE_PSEUDO_CLASS(mozSuppressed, ":-moz-suppressed",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_SUPPRESSED)
 CSS_STATE_PSEUDO_CLASS(mozTypeUnsupported, ":-moz-type-unsupported",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_TYPE_UNSUPPORTED)
 CSS_STATE_PSEUDO_CLASS(mozTypeUnsupportedPlatform, ":-moz-type-unsupported-platform",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_TYPE_UNSUPPORTED_PLATFORM)
 CSS_STATE_PSEUDO_CLASS(mozHandlerClickToPlay, ":-moz-handler-clicktoplay",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_TYPE_CLICK_TO_PLAY)
 CSS_STATE_PSEUDO_CLASS(mozHandlerVulnerableUpdatable, ":-moz-handler-vulnerable-updatable",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_VULNERABLE_UPDATABLE)
 CSS_STATE_PSEUDO_CLASS(mozHandlerVulnerableNoUpdate, ":-moz-handler-vulnerable-no-update",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_VULNERABLE_NO_UPDATE)
 CSS_STATE_PSEUDO_CLASS(mozHandlerDisabled, ":-moz-handler-disabled",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_HANDLER_DISABLED)
 CSS_STATE_PSEUDO_CLASS(mozHandlerBlocked, ":-moz-handler-blocked",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_HANDLER_BLOCKED)
 CSS_STATE_PSEUDO_CLASS(mozHandlerCrashed, ":-moz-handler-crashed",
-                       CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME, "",
+                       CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME, "",
                        NS_EVENT_STATE_HANDLER_CRASHED)
 
 CSS_STATE_PSEUDO_CLASS(mozMathIncrementScriptLevel,
                        ":-moz-math-increment-script-level", 0, "",
                        NS_EVENT_STATE_INCREMENT_SCRIPT_LEVEL)
 
 // CSS 3 UI
 // http://www.w3.org/TR/2004/CR-css3-ui-20040511/#pseudo-classes
--- a/layout/style/nsCSSPseudoClasses.cpp
+++ b/layout/style/nsCSSPseudoClasses.cpp
@@ -20,24 +20,16 @@ using namespace mozilla;
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
 
 #define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_) \
   NS_STATIC_ATOM_BUFFER(name_##_pseudo_class_buffer, value_)
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
 
-#define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_) \
-  static_assert(!((flags_) & CSS_PSEUDO_CLASS_ENABLED_IN_CHROME) || \
-                ((flags_) & CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS), \
-                "Pseudo-class '" #name_ "' is enabled in chrome, so it " \
-                "should also be enabled in UA sheets");
-#include "nsCSSPseudoClassList.h"
-#undef CSS_PSEUDO_CLASS
-
 // Array of nsStaticAtom for each of the pseudo-classes.
 static const nsStaticAtom CSSPseudoClasses_info[] = {
 #define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_) \
   NS_STATIC_ATOM(name_##_pseudo_class_buffer, &sPseudoClass_##name_),
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
 };
 
@@ -47,28 +39,20 @@ static const nsStaticAtom CSSPseudoClass
 static const uint32_t CSSPseudoClasses_flags[] = {
 #define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_) \
   flags_,
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
 };
 
 static bool sPseudoClassEnabled[] = {
-// If the pseudo class has any "ENABLED_IN" flag set, it is disabled by
-// default. Note that, if a pseudo class has pref, whatever its default
-// value is, it'll later be changed in nsCSSPseudoClasses::AddRefAtoms()
-// If the pseudo class has "ENABLED_IN" flags but doesn't have a pref,
-// it is an internal pseudo class which is disabled elsewhere.
-#define IS_ENABLED_BY_DEFAULT(flags_) \
-  (!((flags_) & CSS_PSEUDO_CLASS_ENABLED_MASK))
 #define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_) \
-  IS_ENABLED_BY_DEFAULT(flags_),
+  true,
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
-#undef IS_ENABLED_BY_DEFAULT
 };  
 
 void nsCSSPseudoClasses::AddRefAtoms()
 {
   NS_RegisterStaticAtoms(CSSPseudoClasses_info);
   
 #define CSS_PSEUDO_CLASS(name_, value_, flags_, pref_)                       \
   if (pref_[0]) {                                                            \
@@ -101,35 +85,22 @@ nsCSSPseudoClasses::HasNthPairArg(Type a
 void
 nsCSSPseudoClasses::PseudoTypeToString(Type aType, nsAString& aString)
 {
   MOZ_ASSERT(aType < ePseudoClass_Count, "Unexpected type");
   MOZ_ASSERT(aType >= 0, "Very unexpected type");
   (*CSSPseudoClasses_info[aType].mAtom)->ToString(aString);
 }
 
-/* static */ nsCSSPseudoClasses::Type
-nsCSSPseudoClasses::GetPseudoType(nsIAtom* aAtom,
-                                  bool aAgentEnabled, bool aChromeEnabled)
+nsCSSPseudoClasses::Type
+nsCSSPseudoClasses::GetPseudoType(nsIAtom* aAtom)
 {
   for (uint32_t i = 0; i < ArrayLength(CSSPseudoClasses_info); ++i) {
     if (*CSSPseudoClasses_info[i].mAtom == aAtom) {
-      Type type = Type(i);
-      if (sPseudoClassEnabled[i]) {
-        return type;
-      } else {
-        auto flags = FlagsForPseudoClass(type);
-        if ((aChromeEnabled &&
-             (flags & CSS_PSEUDO_CLASS_ENABLED_IN_CHROME)) ||
-            (aAgentEnabled &&
-             (flags & CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS))) {
-          return type;
-        }
-      }
-      return ePseudoClass_NotPseudoClass;
+      return sPseudoClassEnabled[i] ? Type(i) : ePseudoClass_NotPseudoClass;
     }
   }
 
   return nsCSSPseudoClasses::ePseudoClass_NotPseudoClass;
 }
 
 /* static */ bool
 nsCSSPseudoClasses::IsUserActionPseudoClass(Type aType)
--- a/layout/style/nsCSSPseudoClasses.h
+++ b/layout/style/nsCSSPseudoClasses.h
@@ -5,30 +5,20 @@
 
 /* atom list for CSS pseudo-classes */
 
 #ifndef nsCSSPseudoClasses_h___
 #define nsCSSPseudoClasses_h___
 
 #include "nsStringFwd.h"
 
-// The following two flags along with the pref defines where this pseudo
-// class can be used:
-// * If none of the two flags is presented, the pref completely controls
-//   the availability of this pseudo class. And in that case, if it has
-//   no pref, this property is usable everywhere.
-// * If any of the flags is set, this pseudo class is always enabled in
-//   the specific contexts regardless of the value of the pref. If there
-//   is no pref for this pseudo class at all in this case, it is an
-//   internal-only pseudo class, which cannot be used anywhere else.
-#define CSS_PSEUDO_CLASS_ENABLED_MASK                  (3<<0)
-#define CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS          (1<<0)
-#define CSS_PSEUDO_CLASS_ENABLED_IN_CHROME             (1<<1)
-#define CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME \
-  (CSS_PSEUDO_CLASS_ENABLED_IN_UA_SHEETS | CSS_PSEUDO_CLASS_ENABLED_IN_CHROME)
+// This pseudo-class is accepted only in UA style sheets.
+#define CSS_PSEUDO_CLASS_UA_SHEET_ONLY                 (1<<0)
+// This pseudo-class is accepted only in UA style sheets and chrome.
+#define CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME           (1<<1)
 
 class nsIAtom;
 
 class nsCSSPseudoClasses {
 public:
 
   static void AddRefAtoms();
 
@@ -37,25 +27,37 @@ public:
     ePseudoClass_##_name,
 #include "nsCSSPseudoClassList.h"
 #undef CSS_PSEUDO_CLASS
     ePseudoClass_Count,
     ePseudoClass_NotPseudoClass /* This value MUST be last!  SelectorMatches
                                    depends on it. */
   };
 
-  static Type GetPseudoType(nsIAtom* aAtom,
-                            bool aAgentEnabled, bool aChromeEnabled);
+  static Type GetPseudoType(nsIAtom* aAtom);
   static bool HasStringArg(Type aType);
   static bool HasNthPairArg(Type aType);
   static bool HasSelectorListArg(Type aType) {
     return aType == ePseudoClass_any;
   }
   static bool IsUserActionPseudoClass(Type aType);
 
+  static bool PseudoClassIsUASheetOnly(Type aType) {
+    return PseudoClassHasFlags(aType, CSS_PSEUDO_CLASS_UA_SHEET_ONLY);
+  }
+  static bool PseudoClassIsUASheetAndChromeOnly(Type aType) {
+    return PseudoClassHasFlags(aType, CSS_PSEUDO_CLASS_UA_SHEET_AND_CHROME);
+  }
+
   // Should only be used on types other than Count and NotPseudoClass
   static void PseudoTypeToString(Type aType, nsAString& aString);
 
 private:
   static uint32_t FlagsForPseudoClass(const Type aType);
+
+  // Does the given pseudo-class have all of the flags given?
+  static bool PseudoClassHasFlags(const Type aType, uint32_t aFlags)
+  {
+    return (FlagsForPseudoClass(aType) & aFlags) == aFlags;
+  }
 };
 
 #endif /* nsCSSPseudoClasses_h___ */
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -4539,21 +4539,16 @@ pref("dom.webnotifications.serviceworker
 
 // Alert animation effect, name is disableSlidingEffect for backwards-compat.
 pref("alerts.disableSlidingEffect", false);
 // Show favicons in web notifications.
 pref("alerts.showFavicons", false);
 
 // DOM full-screen API.
 pref("full-screen-api.enabled", false);
-#ifdef RELEASE_BUILD
-pref("full-screen-api.unprefix.enabled", false);
-#else
-pref("full-screen-api.unprefix.enabled", true);
-#endif
 pref("full-screen-api.allow-trusted-requests-only", true);
 pref("full-screen-api.pointer-lock.enabled", true);
 // transition duration of fade-to-black and fade-from-black, unit: ms
 pref("full-screen-api.transition-duration.enter", "200 200");
 pref("full-screen-api.transition-duration.leave", "200 200");
 // timeout for black screen in fullscreen transition, unit: ms
 pref("full-screen-api.transition.timeout", 500);
 // time for the warning box stays on the screen before sliding out, unit: ms