Bug 805301 - Rename iframe.mozallowfullscreen to allowfullscreen. r=jlebar, a=bajaj
authorChris Pearce <cpearce@mozilla.com>
Thu, 08 Nov 2012 16:05:36 -0500
changeset 114055 5eb344f86efbc43000307db37b36ecd6214165aa
parent 114054 bf90268060e18d58b68677fadedb28629b799722
child 114056 4dbb66879cf5db998180834bd6ee040b3dd0669e
push id2622
push userryanvm@gmail.com
push dateThu, 08 Nov 2012 21:46:52 +0000
treeherdermozilla-aurora@4dbb66879cf5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjlebar, bajaj
bugs805301
milestone18.0a2
Bug 805301 - Rename iframe.mozallowfullscreen to allowfullscreen. r=jlebar, a=bajaj
b2g/chrome/content/shell.js
browser/base/content/test/test_contextmenu.html
content/base/src/nsDocument.cpp
content/base/src/nsGkAtomList.h
content/html/content/src/nsHTMLIFrameElement.cpp
content/html/content/test/file_fullscreen-api.html
content/html/content/test/file_fullscreen-denied-inner.html
content/html/content/test/file_fullscreen-denied.html
content/html/content/test/file_fullscreen-hidden.html
content/html/content/test/file_fullscreen-navigation.html
content/html/content/test/file_fullscreen-rollback.html
content/html/content/test/test_fullscreen-api.html
docshell/base/nsDocShell.cpp
docshell/base/nsDocShell.h
docshell/base/nsIDocShell.idl
dom/browser-element/BrowserElementParent.js
dom/interfaces/core/nsIDOMDocument.idl
dom/interfaces/html/nsIDOMHTMLIFrameElement.idl
dom/tests/mochitest/pointerlock/file_allowPointerLockSandboxFlag.html
dom/tests/mochitest/pointerlock/test_pointerlock-api.html
--- a/b2g/chrome/content/shell.js
+++ b/b2g/chrome/content/shell.js
@@ -171,25 +171,25 @@ var shell = {
     if (!homeURL) {
       let msg = 'Fatal error during startup: No homescreen found: try setting B2G_HOMESCREEN';
       alert(msg);
       return;
     }
 
     let manifestURL = this.manifestURL;
     // <html:iframe id="homescreen"
-    //              mozbrowser="true" mozallowfullscreen="true"
+    //              mozbrowser="true" allowfullscreen="true"
     //              style="overflow: hidden; -moz-box-flex: 1; border: none;"
     //              src="data:text/html;charset=utf-8,%3C!DOCTYPE html>%3Cbody style='background:black;'>"/>
     let browserFrame =
       document.createElementNS('http://www.w3.org/1999/xhtml', 'html:iframe');
     browserFrame.setAttribute('id', 'homescreen');
     browserFrame.setAttribute('mozbrowser', 'true');
     browserFrame.setAttribute('mozapp', manifestURL);
-    browserFrame.setAttribute('mozallowfullscreen', 'true');
+    browserFrame.setAttribute('allowfullscreen', 'true');
     browserFrame.setAttribute('style', "overflow: hidden; -moz-box-flex: 1; border: none;");
     browserFrame.setAttribute('src', "data:text/html;charset=utf-8,%3C!DOCTYPE html>%3Cbody style='background:black;");
     document.getElementById('shell').appendChild(browserFrame);
 
     browserFrame.contentWindow
                 .QueryInterface(Ci.nsIInterfaceRequestor)
                 .getInterface(Ci.nsIWebNavigation)
                 .sessionHistory = Cc["@mozilla.org/browser/shistory;1"]
--- a/browser/base/content/test/test_contextmenu.html
+++ b/browser/base/content/test/test_contextmenu.html
@@ -825,17 +825,17 @@ function startTest() {
     ok(contextMenu, "Got context menu XUL");
 
     if (chromeWin.document.getElementById("Browser:Stop").getAttribute("disabled") != "true") {
       todo(false, "Wait for subwindow to load... (This should usually happen once.)");
       SimpleTest.executeSoon(startTest);
       return;
     }
 
-    subwindow.mozAllowFullScreen = true;
+    subwindow.allowfullscreen = true;
     lastElement = null;
 
     text   = subwindow.document.getElementById("test-text");
     link   = subwindow.document.getElementById("test-link");
     imagelink = subwindow.document.getElementById("test-image-link");
     mailto = subwindow.document.getElementById("test-mailto");
     input  = subwindow.document.getElementById("test-input");
     img    = subwindow.document.getElementById("test-image");
--- a/content/base/src/nsDocument.cpp
+++ b/content/base/src/nsDocument.cpp
@@ -9473,17 +9473,17 @@ nsDocument::IsFullScreenEnabled(bool aCa
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedHidden", this);
     return false;
   }
   if (HasFullScreenSubDocument(this)) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedSubDocFullScreen", this);
     return false;
   }
 
-  // Ensure that all ancestor <iframe> elements have the mozallowfullscreen
+  // Ensure that all ancestor <iframe> elements have the allowfullscreen
   // boolean attribute set.
   nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mDocumentContainer);
   bool allowed = false;
   if (docShell) {
     docShell->GetFullscreenAllowed(&allowed);
   }
   if (!allowed) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedIframeDisallowed", this);
--- a/content/base/src/nsGkAtomList.h
+++ b/content/base/src/nsGkAtomList.h
@@ -68,16 +68,17 @@ GK_ATOM(after, "after")
 GK_ATOM(after_end, "after_end")
 GK_ATOM(after_start, "after_start")
 GK_ATOM(align, "align")
 GK_ATOM(alink, "alink")
 GK_ATOM(all, "all")
 GK_ATOM(allowevents, "allowevents")
 GK_ATOM(allowforms, "allow-forms")
 GK_ATOM(allownegativeassertions, "allownegativeassertions")
+GK_ATOM(allowfullscreen, "allowfullscreen")
 GK_ATOM(allowsameorigin, "allow-same-origin")
 GK_ATOM(allowscripts, "allow-scripts")
 GK_ATOM(allowtopnavigation, "allow-top-navigation")
 GK_ATOM(allowuntrusted, "allowuntrusted")
 GK_ATOM(alt, "alt")
 GK_ATOM(alternate, "alternate")
 GK_ATOM(always, "always")
 GK_ATOM(ancestor, "ancestor")
--- a/content/html/content/src/nsHTMLIFrameElement.cpp
+++ b/content/html/content/src/nsHTMLIFrameElement.cpp
@@ -50,17 +50,17 @@ NS_IMPL_STRING_ATTR(nsHTMLIFrameElement,
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, Height, height)
 NS_IMPL_URI_ATTR(nsHTMLIFrameElement, LongDesc, longdesc)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, MarginHeight, marginheight)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, MarginWidth, marginwidth)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, Name, name)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, Scrolling, scrolling)
 NS_IMPL_URI_ATTR(nsHTMLIFrameElement, Src, src)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, Width, width)
-NS_IMPL_BOOL_ATTR(nsHTMLIFrameElement, MozAllowFullScreen, mozallowfullscreen)
+NS_IMPL_BOOL_ATTR(nsHTMLIFrameElement, Allowfullscreen, allowfullscreen)
 NS_IMPL_STRING_ATTR(nsHTMLIFrameElement, Sandbox, sandbox)
 
 void
 nsHTMLIFrameElement::GetItemValueText(nsAString& aValue)
 {
   GetSrc(aValue);
 }
 
--- a/content/html/content/test/file_fullscreen-api.html
+++ b/content/html/content/test/file_fullscreen-api.html
@@ -75,17 +75,17 @@ function fullScreenChange(event) {
       is(document.mozFullScreenElement, null, "8. Full-screen element should still be null after re-adding former FSE.");
       break;
     }
     case 1: {
       ok(!document.mozFullScreen, "9. Should have left full-screen mode (first time)");
       is(event.target, document, "10. Event target should be full-screen document #2");
       is(document.mozFullScreenElement, null, "11. Full-screen element should be null.");
       iframe = document.createElement("iframe");
-      iframe.mozAllowFullScreen = true;
+      iframe.allowfullscreen = true;
       document.body.appendChild(iframe);
       iframe.src = iframeContents;
       break;
     }
     case 2: {
       ok(document.mozFullScreen, "12. Should be back in full-screen mode (second time)");
       is(event.target, document, "13. Event target should be full-screen document #3");
       is(document.mozFullScreenElement, iframe, "14. Full-screen element should be iframe element.");
@@ -208,17 +208,17 @@ function fullScreenChange(event) {
           ok(!document.mozFullScreen, "Should still be in normal mode, because pref is not enabled.");
 
           SpecialPowers.setBoolPref("full-screen-api.enabled", true);
           is(document.mozFullScreenEnabled, true, "document.mozFullScreenEnabled should be true if full-screen-api.enabled is true");
 
           iframe = document.createElement("iframe");
           fullScreenElement().appendChild(iframe);
           iframe.src = iframeContents;
-          ok(!document.mozFullScreen, "Should still be in normal mode, because iframe did not have mozallowfullscreen attribute.");
+          ok(!document.mozFullScreen, "Should still be in normal mode, because iframe did not have allowfullscreen attribute.");
           fullScreenElement().removeChild(iframe);
           iframe = null;
 
           // Set timeout for calling finish(), so that any pending "mozfullscreenchange" events
           // would have a chance to fire.
           setTimeout(function(){opener.nextTest();}, 0);
         }, 0);
       break;
--- a/content/html/content/test/file_fullscreen-denied-inner.html
+++ b/content/html/content/test/file_fullscreen-denied-inner.html
@@ -1,22 +1,22 @@
 <html>
   <body onload='foo();'>
   <script>
     function foo() {
       document.addEventListener('mozfullscreenerror',
         function() {
-          parent.ok(true, "Request from an iframe without mozallowfullscreen should be denied");
+          parent.ok(true, "Request from an iframe without allowfullscreen should be denied");
           parent.finish();
         },
         false);
       document.addEventListener('mozfullscreenchange',
         function() {
-          parent.ok(false, "Request from an iframe without mozallowfullscreen should be denied, but was granted!");
+          parent.ok(false, "Request from an iframe without allowfullscreen should be denied, but was granted!");
           parent.finish();
         },
         false);
-      parent.is(document.mozFullScreenEnabled, false, "Full-screen should not be enabled, coz mozallowfullscreen isn't present.");
+      parent.is(document.mozFullScreenEnabled, false, "Full-screen should not be enabled, coz allowfullscreen isn't present.");
       document.body.mozRequestFullScreen();    
     }
   </script>
   </body>
 </html>
--- a/content/html/content/test/file_fullscreen-denied.html
+++ b/content/html/content/test/file_fullscreen-denied.html
@@ -74,17 +74,17 @@ function keyHandler(event) {
     function() {
       ok(fullscreendenied, "Request in long running event handler should be denied");
       ok(!document.mozFullScreen, "Should not grant request in long-running event handler.");
       
       // Disable the requirement for trusted contexts only, so the tests are easier
       // to write.
       SpecialPowers.setBoolPref("full-screen-api.allow-trusted-requests-only", false);  
       
-      // Create an iframe without a mozallowfullscreen attribute, whose contents requests
+      // Create an iframe without a allowfullscreen attribute, whose contents requests
       // full-screen. The request should be denied, and we should not receive a fullscreenchange
       // event in this document.
       var iframe = document.createElement("iframe");
       iframe.src = "file_fullscreen-denied-inner.html";
       document.body.appendChild(iframe);
     }, 0);
 }
 
--- a/content/html/content/test/file_fullscreen-hidden.html
+++ b/content/html/content/test/file_fullscreen-hidden.html
@@ -5,17 +5,17 @@ https://bugzilla.mozilla.org/show_bug.cg
 -->
 <head>
   <title>Test for Bug 697636</title>
   <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
 </head>
 <body>
 
-<iframe id="f" src="data:text/html,<body text=green>1" mozallowfullscreen></iframe>
+<iframe id="f" src="data:text/html,<body text=green>1" allowfullscreen></iframe>
 
 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697636">Mozilla Bug 697636</a>
 <p id="display"></p>
 <div id="content" style="display: none">
   
 </div>
 <pre id="test">
 <script type="application/javascript">
--- a/content/html/content/test/file_fullscreen-navigation.html
+++ b/content/html/content/test/file_fullscreen-navigation.html
@@ -5,17 +5,17 @@ https://bugzilla.mozilla.org/show_bug.cg
 -->
 <head>
   <title>Test for Bug 685402</title>
   <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
 </head>
 <body style="background-color: gray;">
 
-<iframe id="f" src="data:text/html,<body text=green>1" mozallowfullscreen></iframe>
+<iframe id="f" src="data:text/html,<body text=green>1" allowfullscreen></iframe>
 
 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=685402">Mozilla Bug 685402</a>
 <p id="display"></p>
 <div id="content" style="display: none">
   
 </div>
 <pre id="test">
 <script type="application/javascript">
--- a/content/html/content/test/file_fullscreen-rollback.html
+++ b/content/html/content/test/file_fullscreen-rollback.html
@@ -19,17 +19,17 @@ Tests:
 <head>
   <title>Test for Bug 700764</title>
   <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
 </head>
 <body>
 
 <div id="fse">
   <div id="fse-inner">
-    <iframe id="subdoc" mozallowfullscreen src="data:text/html,<html><body bgcolor='black'></body></html>"></iframe>
+    <iframe id="subdoc" allowfullscreen src="data:text/html,<html><body bgcolor='black'></body></html>"></iframe>
   </div>
 </div>
 
 <div id="non-fse"></div>
 
 <script type="application/javascript">
 
 /** Test for Bug 700764 **/
--- a/content/html/content/test/test_fullscreen-api.html
+++ b/content/html/content/test/test_fullscreen-api.html
@@ -26,17 +26,17 @@
 // Ensure the full-screen api is enabled, and will be disabled on test exit.
 SpecialPowers.setBoolPref("full-screen-api.enabled", true);
 
 // Disable the requirement for trusted contexts only, so the tests are easier
 // to write.
 SpecialPowers.setBoolPref("full-screen-api.allow-trusted-requests-only", false);
 
 // Run the tests which go full-screen in new windows, as mochitests normally
-// run in an iframe, which by default will not have the mozallowfullscreen
+// run in an iframe, which by default will not have the allowfullscreen
 // attribute set, so full-screen won't work.
 var gTestWindows = [
   "file_fullscreen-rollback.html",
   "file_fullscreen-esc-exit.html",
   "file_fullscreen-denied.html",
   "file_fullscreen-api.html",
   "file_fullscreen-api-keys.html",
   "file_fullscreen-plugins.html",
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -2151,32 +2151,33 @@ nsDocShell::GetFullscreenAllowed(bool* a
         *aFullscreenAllowed = (mFullscreenAllowed == PARENT_ALLOWS);
         return NS_OK;
     }
 
     // Assume false until we determine otherwise...
     *aFullscreenAllowed = false;
 
     // For non-content boundaries, check that the enclosing iframe element
-    // has the mozallowfullscreen attribute set to true. If any ancestor
-    // iframe does not have mozallowfullscreen=true, then fullscreen is
+    // has the allowfullscreen attribute set to true. If any ancestor
+    // iframe does not have allowfullscreen=true, then fullscreen is
     // prohibited.
     nsCOMPtr<nsPIDOMWindow> win = do_GetInterface(GetAsSupports(this));
     if (!win) {
         return NS_OK;
     }
     nsCOMPtr<nsIContent> frameElement = do_QueryInterface(win->GetFrameElementInternal());
     if (frameElement &&
         frameElement->IsHTML(nsGkAtoms::iframe) &&
+        !frameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::allowfullscreen) &&
         !frameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::mozallowfullscreen)) {
         return NS_OK;
     }
 
     // If we have no parent then we're the root docshell; no ancestor of the
-    // original docshell doesn't have a mozallowfullscreen attribute, so
+    // original docshell doesn't have a allowfullscreen attribute, so
     // report fullscreen as allowed.
     nsCOMPtr<nsIDocShellTreeItem> dsti = do_GetInterface(GetAsSupports(this));
     NS_ENSURE_TRUE(dsti, NS_OK);
 
     nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
     dsti->GetParent(getter_AddRefs(parentTreeItem));
     if (!parentTreeItem) {
         *aFullscreenAllowed = true;
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -775,24 +775,24 @@ protected:
     // transaction at the time that this DocShell begins to load
     int32_t                    mPreviousTransIndex;
     int32_t                    mLoadedTransIndex;
 
     uint32_t                   mSandboxFlags;
 
     // mFullscreenAllowed stores how we determine whether fullscreen is allowed
     // when GetFullscreenAllowed() is called. Fullscreen is allowed in a
-    // docshell when all containing iframes have the mozallowfullscreen
+    // docshell when all containing iframes have the allowfullscreen
     // attribute set to true. When mFullscreenAllowed is CHECK_ATTRIBUTES
-    // we check this docshell's containing frame for the mozallowfullscreen
+    // we check this docshell's containing frame for the allowfullscreen
     // attribute, and recurse onto the parent docshell to ensure all containing
-    // frames also have the mozallowfullscreen attribute. If we find an ancestor
+    // frames also have the allowfullscreen attribute. If we find an ancestor
     // docshell with mFullscreenAllowed not equal to CHECK_ATTRIBUTES, we've
     // reached a content boundary, and mFullscreenAllowed denotes whether the
-    // parent across the content boundary has mozallowfullscreen=true in all its
+    // parent across the content boundary has allowfullscreen=true in all its
     // containing iframes. mFullscreenAllowed defaults to CHECK_ATTRIBUTES and
     // is set otherwise when docshells which are content boundaries are created.
     enum FullscreenAllowedState {
         CHECK_ATTRIBUTES,
         PARENT_ALLOWS,
         PARENT_PROHIBITS
     };
     FullscreenAllowedState     mFullscreenAllowed;
--- a/docshell/base/nsIDocShell.idl
+++ b/docshell/base/nsIDocShell.idl
@@ -685,19 +685,19 @@ interface nsIDocShell : nsISupports
    * not be allowed.
    */
   [noscript, notxpcom] bool pluginsAllowedInCurrentDoc();
   
 
   /**
    * Attribute that determines whether fullscreen is allowed to be entered for
    * this subtree of the docshell tree. This is true when all iframes containing
-   * this docshell have their "mozallowfullscreen" attribute set to "true".
+   * this docshell have their "allowfullscreen" attribute set to "true".
    * fullscreenAllowed is only writable at content boundaries, where it is used
    * to propagate the value of the cross process parent's iframe's
-   * "mozallowfullscreen" attribute to the child process. Setting
+   * "allowfullscreen" attribute to the child process. Setting
    * fullscreenAllowed on docshells which aren't content boundaries throws an
    * exception.
    */
   [infallible] readonly attribute boolean fullscreenAllowed;
   
   void setFullscreenAllowed(in boolean allowed);
 };
--- a/dom/browser-element/BrowserElementParent.js
+++ b/dom/browser-element/BrowserElementParent.js
@@ -368,19 +368,20 @@ BrowserElementParent.prototype = {
     if (this._window.document.mozHidden) {
       this._ownerVisibilityChange();
     }
   },
 
   _recvGetName: function(data) {
     return this._frameElement.getAttribute('name');
   },
-  
+
   _recvGetFullscreenAllowed: function(data) {
-    return this._frameElement.hasAttribute('mozallowfullscreen');
+    return this._frameElement.hasAttribute('allowfullscreen') ||
+           this._frameElement.hasAttribute('mozallowfullscreen');
   },
 
   _fireCtxMenuEvent: function(data) {
     let evtName = data.name.substring('browser-element-api:'.length);
     let detail = data.json;
 
     debug('fireCtxMenuEventFromMsg: ' + evtName + ' ' + detail);
     let evt = this._createEvent(evtName, detail);
--- a/dom/interfaces/core/nsIDOMDocument.idl
+++ b/dom/interfaces/core/nsIDOMDocument.idl
@@ -346,17 +346,17 @@ interface nsIDOMDocument : nsIDOMNode
    *
    * @see <https://wiki.mozilla.org/index.php?title=Gecko:FullScreenAPI>
    */
   readonly attribute boolean mozFullScreen;  
 
   /**
    * Denotes whether the full-screen-api.enabled is true, no windowed
    * plugins are present, and all ancestor documents have the
-   * mozallowfullscreen attribute set.
+   * allowfullscreen attribute set.
    *
    * @see <https://wiki.mozilla.org/index.php?title=Gecko:FullScreenAPI>
    */
   readonly attribute boolean mozFullScreenEnabled;
 
   /**
    * The element to which the mouse pointer is locked, if any, as per the
    * DOM pointer lock api.
--- a/dom/interfaces/html/nsIDOMHTMLIFrameElement.idl
+++ b/dom/interfaces/html/nsIDOMHTMLIFrameElement.idl
@@ -11,17 +11,17 @@
  *
  * This interface is trying to follow the DOM Level 2 HTML specification:
  * http://www.w3.org/TR/DOM-Level-2-HTML/
  *
  * with changes from the work-in-progress WHATWG HTML specification:
  * http://www.whatwg.org/specs/web-apps/current-work/
  */
 
-[scriptable, uuid(52f6244b-b1f5-4f4c-8ff3-7e146316f411)]
+[scriptable, uuid(a7bd1e34-3969-47ae-8c1d-2970132ba925)]
 interface nsIDOMHTMLIFrameElement : nsIDOMHTMLElement
 {
            attribute DOMString        align;
            attribute DOMString        frameBorder;
            attribute DOMString        height;
            attribute DOMString        longDesc;
            attribute DOMString        marginHeight;
            attribute DOMString        marginWidth;
@@ -30,13 +30,13 @@ interface nsIDOMHTMLIFrameElement : nsID
            attribute DOMString        src;
            attribute DOMString        width;
   // Introduced in DOM Level 2:
   readonly attribute nsIDOMDocument   contentDocument;
   readonly attribute nsIDOMWindow     contentWindow;
 
            attribute DOMString        sandbox;
   // Mozilla extensions
-  // iframe elements require the mozAllowFullScreen attribute to be present
+  // iframe elements require the allowfullscreen attribute to be present
   // if they're to allow content in the sub document to go into DOM full-screen
   // mode. See https://wiki.mozilla.org/index.php?title=Gecko:FullScreenAPI
-           attribute boolean          mozAllowFullScreen;
+           attribute boolean          allowfullscreen;
 };
--- a/dom/tests/mochitest/pointerlock/file_allowPointerLockSandboxFlag.html
+++ b/dom/tests/mochitest/pointerlock/file_allowPointerLockSandboxFlag.html
@@ -13,17 +13,17 @@
     <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
   </head>
   <body>
     <a target="_blank"
        href="https://bugzilla.mozilla.org/show_bug.cgi?id=784402">
       Mozilla Bug 784402</a>
     <p id="display"></p>
 
-    <iframe src ="iframe_differentDOM.html" mozallowfullscreen="true" id="iframe"
+    <iframe src ="iframe_differentDOM.html" allowfullscreen="true" id="iframe"
       onload="startTest()"
       sandbox="allow-scripts allow-same-origin allow-pointer-lock">
     </iframe>
 
     <pre id="test">
       <script type="application/javascript">
         /*
          * Test for Bug 784402
--- a/dom/tests/mochitest/pointerlock/test_pointerlock-api.html
+++ b/dom/tests/mochitest/pointerlock/test_pointerlock-api.html
@@ -15,17 +15,17 @@ https://bugzilla.mozilla.org/show_bug.cg
     </a>
     <div id="content">
     </div>
     <pre id="test">
       <script type="application/javascript">
         /**
          * Pointer Lock tests for bug 633602.  These depend on the fullscreen api
          * which doesn't work when run in the mochitests' iframe, since the
-         * mochitests' iframe doesn't have a mozallowfullscreen attribute.  To get
+         * mochitests' iframe doesn't have a allowfullscreen attribute.  To get
          * around this, all tests are run in a child window, which can go fullscreen.
          * This method is borrowed from content/html/content/test/test_fullscreen-api.html.
          **/
 
         SimpleTest.waitForExplicitFinish();
 
         // Ensure the full-screen api is enabled, and will be disabled on test exit.
         SpecialPowers.setBoolPref("full-screen-api.enabled", true);
@@ -34,17 +34,17 @@ https://bugzilla.mozilla.org/show_bug.cg
         SpecialPowers.setBoolPref("full-screen-api.allow-trusted-requests-only", false);
 
         // Grant "fullscreen" permission on the test domain. This means fullscreen will be
         // automatically approved, so pointer lock in the tests will be too.
         SpecialPowers.setFullscreenAllowed(document);
         
         // Run the tests which go full-screen in new window, as Mochitests
         // normally run in an iframe, which by default will not have the
-        // mozallowfullscreen attribute set, so full-screen won't work.
+        // allowfullscreen attribute set, so full-screen won't work.
         var gTestFiles = [
           "file_approval.html",
           "file_screenClientXYConst.html",
           "file_childIframe.html",
           "file_doubleLock.html",
           "file_escapeKey.html",
           "file_infiniteMovement.html",
           "file_locksvgelement.html",