Bug 1376357 - Automatically fix ESLint issues in dom/media/*.js*. r=bwc
authorMark Banner <standard8@mozilla.com>
Wed, 28 Jun 2017 12:41:50 -0700
changeset 366804 61a73c8436a7d9f4c22ff0fb0b35624de9f5fb15
parent 366803 27aa42ed32351009f5c5f7d3dfb5551c6e5bb41e
child 366805 5206e8f59b668813934a9ab799f2341f51800e9a
push id92071
push usercbook@mozilla.com
push dateFri, 30 Jun 2017 13:12:39 +0000
treeherdermozilla-inbound@d865e836f74a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbwc
bugs1376357
milestone56.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1376357 - Automatically fix ESLint issues in dom/media/*.js*. r=bwc MozReview-Commit-ID: 6JXIHvJoZqS
.eslintignore
dom/media/IdpSandbox.jsm
dom/media/PeerConnection.js
dom/media/PeerConnectionIdp.jsm
--- a/.eslintignore
+++ b/.eslintignore
@@ -210,16 +210,17 @@ dom/imptests/**
 dom/interfaces/**
 dom/ipc/**
 dom/json/**
 dom/jsurl/**
 dom/locales/**
 dom/manifest/**
 dom/mathml/**
 dom/media/**
+!dom/media/*.js*
 dom/messagechannel/**
 dom/network/**
 dom/notification/**
 dom/offline/**
 dom/payments/**
 dom/performance/**
 dom/permission/**
 dom/plugins/**
@@ -246,16 +247,19 @@ dom/webidl/**
 dom/workers/**
 dom/worklet/**
 dom/xbl/**
 dom/xhr/**
 dom/xml/**
 dom/xslt/**
 dom/xul/**
 
+# Third-party
+dom/media/webvtt/**
+
 # Exclude everything but self-hosted JS
 js/ductwork/**
 js/examples/**
 js/ipc/**
 js/public/**
 js/xpconnect/**
 js/src/devtools/**
 js/src/octane/**
--- a/dom/media/IdpSandbox.jsm
+++ b/dom/media/IdpSandbox.jsm
@@ -1,113 +1,113 @@
 /* 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';
+"use strict";
 
 const {
   classes: Cc,
   interfaces: Ci,
   utils: Cu,
   results: Cr
 } = Components;
 
-Cu.import('resource://gre/modules/Services.jsm');
-Cu.import('resource://gre/modules/NetUtil.jsm');
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
 /** This little class ensures that redirects maintain an https:// origin */
 function RedirectHttpsOnly() {}
 
 RedirectHttpsOnly.prototype = {
-  asyncOnChannelRedirect: function(oldChannel, newChannel, flags, callback) {
-    if (newChannel.URI.scheme !== 'https') {
+  asyncOnChannelRedirect(oldChannel, newChannel, flags, callback) {
+    if (newChannel.URI.scheme !== "https") {
       callback.onRedirectVerifyCallback(Cr.NS_ERROR_ABORT);
     } else {
       callback.onRedirectVerifyCallback(Cr.NS_OK);
     }
   },
 
-  getInterface: function(iid) {
+  getInterface(iid) {
     return this.QueryInterface(iid);
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIChannelEventSink])
 };
 
 /** This class loads a resource into a single string. ResourceLoader.load() is
  * the entry point. */
 function ResourceLoader(res, rej) {
   this.resolve = res;
   this.reject = rej;
-  this.data = '';
+  this.data = "";
 }
 
 /** Loads the identified https:// URL. */
 ResourceLoader.load = function(uri, doc) {
   return new Promise((resolve, reject) => {
     let listener = new ResourceLoader(resolve, reject);
     let ioChannel = NetUtil.newChannel({
-      uri: uri,
+      uri,
       loadingNode: doc,
       securityFlags: Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
       contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_SCRIPT
     });
 
     ioChannel.loadGroup = doc.documentLoadGroup.QueryInterface(Ci.nsILoadGroup);
     ioChannel.notificationCallbacks = new RedirectHttpsOnly();
     ioChannel.asyncOpen2(listener);
   });
 };
 
 ResourceLoader.prototype = {
-  onDataAvailable: function(request, context, input, offset, count) {
-    let stream = Cc['@mozilla.org/scriptableinputstream;1']
+  onDataAvailable(request, context, input, offset, count) {
+    let stream = Cc["@mozilla.org/scriptableinputstream;1"]
       .createInstance(Ci.nsIScriptableInputStream);
     stream.init(input);
     this.data += stream.read(count);
   },
 
-  onStartRequest: function (request, context) {},
+  onStartRequest(request, context) {},
 
-  onStopRequest: function(request, context, status) {
+  onStopRequest(request, context, status) {
     if (Components.isSuccessCode(status)) {
       var statusCode = request.QueryInterface(Ci.nsIHttpChannel).responseStatus;
       if (statusCode === 200) {
-        this.resolve({ request: request, data: this.data });
+        this.resolve({ request, data: this.data });
       } else {
-        this.reject(new Error('Non-200 response from server: ' + statusCode));
+        this.reject(new Error("Non-200 response from server: " + statusCode));
       }
     } else {
-      this.reject(new Error('Load failed: ' + status));
+      this.reject(new Error("Load failed: " + status));
     }
   },
 
-  getInterface: function(iid) {
+  getInterface(iid) {
     return this.QueryInterface(iid);
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIStreamListener])
 };
 
 /**
  * A simple implementation of the WorkerLocation interface.
  */
 function createLocationFromURI(uri) {
   return {
     href: uri.spec,
-    protocol: uri.scheme + ':',
+    protocol: uri.scheme + ":",
     host: uri.host + ((uri.port >= 0) ?
-                      (':' + uri.port) : ''),
+                      (":" + uri.port) : ""),
     port: uri.port,
     hostname: uri.host,
-    pathname: uri.path.replace(/[#\?].*/, ''),
-    search: uri.path.replace(/^[^\?]*/, '').replace(/#.*/, ''),
-    hash: uri.hasRef ? ('#' + uri.ref) : '',
+    pathname: uri.path.replace(/[#\?].*/, ""),
+    search: uri.path.replace(/^[^\?]*/, "").replace(/#.*/, ""),
+    hash: uri.hasRef ? ("#" + uri.ref) : "",
     origin: uri.prePath,
-    toString: function() {
+    toString() {
       return uri.spec;
     }
   };
 }
 
 /**
  * A javascript sandbox for running an IdP.
  *
@@ -119,156 +119,156 @@ function createLocationFromURI(uri) {
 function IdpSandbox(domain, protocol, win) {
   this.source = IdpSandbox.createIdpUri(domain, protocol || "default");
   this.active = null;
   this.sandbox = null;
   this.window = win;
 }
 
 IdpSandbox.checkDomain = function(domain) {
-  if (!domain || typeof domain !== 'string') {
-    throw new Error('Invalid domain for identity provider: ' +
-                    'must be a non-zero length string');
+  if (!domain || typeof domain !== "string") {
+    throw new Error("Invalid domain for identity provider: " +
+                    "must be a non-zero length string");
   }
 };
 
 /**
  * Checks that the IdP protocol is superficially sane.  In particular, we don't
  * want someone adding relative paths (e.g., '../../myuri'), which could be used
  * to move outside of /.well-known/ and into space that they control.
  */
 IdpSandbox.checkProtocol = function(protocol) {
-  let message = 'Invalid protocol for identity provider: ';
-  if (!protocol || typeof protocol !== 'string') {
-    throw new Error(message + 'must be a non-zero length string');
+  let message = "Invalid protocol for identity provider: ";
+  if (!protocol || typeof protocol !== "string") {
+    throw new Error(message + "must be a non-zero length string");
   }
   if (decodeURIComponent(protocol).match(/[\/\\]/)) {
     throw new Error(message + "must not include '/' or '\\'");
   }
 };
 
 /**
  * Turns a domain and protocol into a URI.  This does some aggressive checking
  * to make sure that we aren't being fooled somehow.  Throws on fooling.
  */
 IdpSandbox.createIdpUri = function(domain, protocol) {
   IdpSandbox.checkDomain(domain);
   IdpSandbox.checkProtocol(protocol);
 
-  let message = 'Invalid IdP parameters: ';
+  let message = "Invalid IdP parameters: ";
   try {
-    let wkIdp = 'https://' + domain + '/.well-known/idp-proxy/' + protocol;
-    let ioService = Components.classes['@mozilla.org/network/io-service;1']
+    let wkIdp = "https://" + domain + "/.well-known/idp-proxy/" + protocol;
+    let ioService = Components.classes["@mozilla.org/network/io-service;1"]
                     .getService(Ci.nsIIOService);
     let uri = ioService.newURI(wkIdp);
 
     if (uri.hostPort !== domain) {
-      throw new Error(message + 'domain is invalid');
+      throw new Error(message + "domain is invalid");
     }
-    if (uri.path.indexOf('/.well-known/idp-proxy/') !== 0) {
-      throw new Error(message + 'must produce a /.well-known/idp-proxy/ URI');
+    if (uri.path.indexOf("/.well-known/idp-proxy/") !== 0) {
+      throw new Error(message + "must produce a /.well-known/idp-proxy/ URI");
     }
 
     return uri;
   } catch (e) {
-    if (typeof e.result !== 'undefined' &&
+    if (typeof e.result !== "undefined" &&
                    e.result === Cr.NS_ERROR_MALFORMED_URI) {
-      throw new Error(message + 'must produce a valid URI');
+      throw new Error(message + "must produce a valid URI");
     }
     throw e;
   }
 };
 
 IdpSandbox.prototype = {
-  isSame: function(domain, protocol) {
+  isSame(domain, protocol) {
     return this.source.spec === IdpSandbox.createIdpUri(domain, protocol).spec;
   },
 
-  start: function() {
+  start() {
     if (!this.active) {
       this.active = ResourceLoader.load(this.source, this.window.document)
         .then(result => this._createSandbox(result));
     }
     return this.active;
   },
 
   // Provides the sandbox with some useful facilities.  Initially, this is only
   // a minimal set; it is far easier to add more as the need arises, than to
   // take them back if we discover a mistake.
-  _populateSandbox: function(uri) {
+  _populateSandbox(uri) {
     this.sandbox.location = Cu.cloneInto(createLocationFromURI(uri),
                                          this.sandbox,
                                          { cloneFunctions: true });
   },
 
-  _createSandbox: function(result) {
+  _createSandbox(result) {
     let principal = Services.scriptSecurityManager
       .getChannelResultPrincipal(result.request);
 
     this.sandbox = Cu.Sandbox(principal, {
-      sandboxName: 'IdP-' + this.source.host,
+      sandboxName: "IdP-" + this.source.host,
       wantComponents: false,
       wantExportHelpers: false,
       wantGlobalProperties: [
-        'indexedDB', 'XMLHttpRequest', 'TextEncoder', 'TextDecoder',
-        'URL', 'URLSearchParams', 'atob', 'btoa', 'Blob', 'crypto',
-        'rtcIdentityProvider', 'fetch'
+        "indexedDB", "XMLHttpRequest", "TextEncoder", "TextDecoder",
+        "URL", "URLSearchParams", "atob", "btoa", "Blob", "crypto",
+        "rtcIdentityProvider", "fetch"
       ]
     });
     let registrar = this.sandbox.rtcIdentityProvider;
     if (!Cu.isXrayWrapper(registrar)) {
-      throw new Error('IdP setup failed');
+      throw new Error("IdP setup failed");
     }
 
     // have to use the ultimate URI, not the starting one to avoid
     // that origin stealing from the one that redirected to it
     this._populateSandbox(result.request.URI);
     try {
       Cu.evalInSandbox(result.data, this.sandbox,
-                       'latest', result.request.URI.spec, 1);
+                       "latest", result.request.URI.spec, 1);
     } catch (e) {
       // These can be passed straight on, because they are explicitly labelled
       // as being IdP errors by the IdP and we drop line numbers as a result.
-      if (e.name === 'IdpError' || e.name === 'IdpLoginError') {
+      if (e.name === "IdpError" || e.name === "IdpLoginError") {
         throw e;
       }
       this._logError(e);
-      throw new Error('Error in IdP, check console for details');
+      throw new Error("Error in IdP, check console for details");
     }
 
     if (!registrar.hasIdp) {
-      throw new Error('IdP failed to call rtcIdentityProvider.register()');
+      throw new Error("IdP failed to call rtcIdentityProvider.register()");
     }
     return registrar;
   },
 
   // Capture all the details from the error and log them to the console.  This
   // can't rethrow anything else because that could leak information about the
   // internal workings of the IdP across origins.
-  _logError: function(e) {
+  _logError(e) {
     let winID = this.window.QueryInterface(Ci.nsIInterfaceRequestor)
         .getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
     let scriptError = Cc["@mozilla.org/scripterror;1"]
         .createInstance(Ci.nsIScriptError);
     scriptError.initWithWindowID(e.message, e.fileName, null,
                                  e.lineNumber, e.columnNumber,
                                  Ci.nsIScriptError.errorFlag,
                                  "content javascript", winID);
-    let consoleService = Cc['@mozilla.org/consoleservice;1']
+    let consoleService = Cc["@mozilla.org/consoleservice;1"]
         .getService(Ci.nsIConsoleService);
     consoleService.logMessage(scriptError);
   },
 
-  stop: function() {
+  stop() {
     if (this.sandbox) {
       Cu.nukeSandbox(this.sandbox);
     }
     this.sandbox = null;
     this.active = null;
   },
 
-  toString: function() {
+  toString() {
     return this.source.spec;
   }
 };
 
-this.EXPORTED_SYMBOLS = ['IdpSandbox'];
+this.EXPORTED_SYMBOLS = ["IdpSandbox"];
 this.IdpSandbox = IdpSandbox;
--- a/dom/media/PeerConnection.js
+++ b/dom/media/PeerConnection.js
@@ -43,17 +43,17 @@ const PC_DTMF_SENDER_CID = Components.ID
 function logMsg(msg, file, line, flag, winID) {
   let scriptErrorClass = Cc["@mozilla.org/scripterror;1"];
   let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError);
   scriptError.initWithWindowID(msg, file, null, line, 0, flag,
                                "content javascript", winID);
   let console = Cc["@mozilla.org/consoleservice;1"].
   getService(Ci.nsIConsoleService);
   console.logMessage(scriptError);
-};
+}
 
 let setupPrototype = (_class, dict) => {
   _class.prototype.classDescription = _class.name;
   Object.assign(_class.prototype, dict);
 }
 
 // Global list of PeerConnection objects, so they can be cleaned up when
 // a page is torn down. (Maps inner window ID to an array of PC objects).
@@ -106,26 +106,26 @@ class GlobalPCList {
     }
   }
 
   removeNullRefs(winID) {
     if (this._list[winID] === undefined) {
       return;
     }
     this._list[winID] = this._list[winID].filter(
-      function (e,i,a) { return e.get() !== null; });
+      function(e, i, a) { return e.get() !== null; });
 
     if (this._list[winID].length === 0) {
       delete this._list[winID];
     }
   }
 
   hasActivePeerConnection(winID) {
     this.removeNullRefs(winID);
-    return this._list[winID] ? true : false;
+    return !!this._list[winID];
   }
 
   handleGMPCrash(data) {
     let broadcastPluginCrash = function(list, winID, pluginID, pluginName) {
       if (list.hasOwnProperty(winID)) {
         list[winID].forEach(function(pcref) {
           let pc = pcref.get();
           if (pc) {
@@ -212,17 +212,17 @@ class GlobalPCList {
 }
 setupPrototype(GlobalPCList, {
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
                                          Ci.nsIMessageListener,
                                          Ci.nsISupportsWeakReference,
                                          Ci.IPeerConnectionManager]),
   classID: PC_MANAGER_CID,
   _xpcom_factory: {
-    createInstance: function(outer, iid) {
+    createInstance(outer, iid) {
       if (outer) {
         throw Cr.NS_ERROR_NO_AGGREGATION;
       }
       return _globalPCList.QueryInterface(iid);
     }
   }
 });
 
@@ -333,21 +333,21 @@ class RTCStatsReport {
 
   get mozPcid() { return this._pcid; }
 }
 setupPrototype(RTCStatsReport, {
   classID: PC_STATS_CID,
   contractID: PC_STATS_CONTRACT,
   QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]),
   _specToLegacyFieldMapping: {
-        'inbound-rtp' : 'inboundrtp',
-        'outbound-rtp':'outboundrtp',
-        'candidate-pair':'candidatepair',
-        'local-candidate':'localcandidate',
-        'remote-candidate':'remotecandidate'
+        "inbound-rtp": "inboundrtp",
+        "outbound-rtp": "outboundrtp",
+        "candidate-pair": "candidatepair",
+        "local-candidate": "localcandidate",
+        "remote-candidate": "remotecandidate"
   }
 });
 
 class RTCPeerConnection {
   constructor() {
     this._senders = [];
     this._receivers = [];
 
@@ -612,17 +612,17 @@ class RTCPeerConnection {
         server.urls = [server.urls];
       } else if (!server.urls && server.url) {
         // TODO: Remove support for legacy iceServer.url eventually (Bug 1116766)
         server.urls = [server.url];
         this.logWarning("RTCIceServer.url is deprecated! Use urls instead.");
       }
     });
 
-    let ios = Cc['@mozilla.org/network/io-service;1'].getService(Ci.nsIIOService);
+    let ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
 
     let nicerNewURI = uriStr => {
       try {
         return ios.newURI(uriStr);
       } catch (e) {
         if (e.result == Cr.NS_ERROR_MALFORMED_URI) {
           throw new this._win.DOMException(msg + " - malformed URI: " + uriStr,
                                            "SyntaxError");
@@ -633,41 +633,41 @@ class RTCPeerConnection {
 
     var stunServers = 0;
 
     iceServers.forEach(({ urls, username, credential, credentialType }) => {
       if (!urls) {
         throw new this._win.DOMException(msg + " - missing urls", "InvalidAccessError");
       }
       urls.map(url => nicerNewURI(url)).forEach(({ scheme, spec }) => {
-        if (scheme in { turn:1, turns:1 }) {
+        if (scheme in { turn: 1, turns: 1 }) {
           if (username == undefined) {
             throw new this._win.DOMException(msg + " - missing username: " + spec,
                                              "InvalidAccessError");
           }
           if (credential == undefined) {
             throw new this._win.DOMException(msg + " - missing credential: " + spec,
                                              "InvalidAccessError");
           }
           if (credentialType != "password") {
-            this.logWarning("RTCConfiguration TURN credentialType \""+
+            this.logWarning("RTCConfiguration TURN credentialType \"" +
                             credentialType +
-                            "\" is not yet implemented. Treating as password."+
+                            "\" is not yet implemented. Treating as password." +
                             " https://bugzil.la/1247616");
           }
           this._hasTurnServer = true;
           stunServers += 1;
-        } else if (scheme in { stun:1, stuns:1 }) {
+        } else if (scheme in { stun: 1, stuns: 1 }) {
           this._hasStunServer = true;
           stunServers += 1;
         } else {
           throw new this._win.DOMException(msg + " - improper scheme: " + scheme,
                                            "SyntaxError");
         }
-        if (scheme in { stuns:1, turns:1 }) {
+        if (scheme in { stuns: 1, turns: 1 }) {
           this.logWarning(scheme.toUpperCase() + " is not yet supported.");
         }
         if (stunServers >= 5) {
           this.logError("Using five or more STUN/TURN servers causes problems");
         } else if (stunServers > 2) {
           this.logWarning("Using more than two STUN/TURN servers slows down discovery");
         }
       });
@@ -697,21 +697,21 @@ class RTCPeerConnection {
   logErrorAndCallOnError(e) {
     this.logMsg(e.message, e.fileName, e.lineNumber, Ci.nsIScriptError.exceptionFlag);
 
     // Safely call onerror directly if present (necessary for testing)
     try {
       if (typeof this._win.onerror === "function") {
         this._win.onerror(e.message, e.fileName, e.lineNumber);
       }
-    } catch(e) {
+    } catch (e) {
       // If onerror itself throws, service it.
       try {
         this.logMsg(e.message, e.fileName, e.lineNumber, Ci.nsIScriptError.errorFlag);
-      } catch(e) {}
+      } catch (e) {}
     }
   }
 
   logError(msg) {
     this.logStackMsg(msg, Ci.nsIScriptError.errorFlag);
   }
 
   logWarning(msg) {
@@ -733,26 +733,26 @@ class RTCPeerConnection {
 
   setEH(type, handler) {
     this.__DOM_IMPL__.setEventHandler(type, handler);
   }
 
   makeGetterSetterEH(name) {
     Object.defineProperty(this, name,
                           {
-                            get:function()  { return this.getEH(name); },
-                            set:function(h) { return this.setEH(name, h); }
+                            get() { return this.getEH(name); },
+                            set(h) { return this.setEH(name, h); }
                           });
   }
 
   makeLegacyGetterSetterEH(name, msg) {
     Object.defineProperty(this, name,
                           {
-                            get:function()  { return this.getEH(name); },
-                            set:function(h) {
+                            get() { return this.getEH(name); },
+                            set(h) {
                               this.logWarning(name + " is deprecated! " + msg);
                               return this.setEH(name, h);
                             }
                           });
   }
 
   createOffer(optionsOrOnSucc, onErr, options) {
     // This entry-point handles both new and legacy call sig. Decipher which one
@@ -907,17 +907,17 @@ class RTCPeerConnection {
         if (msg) {
           // Set new identity and generate an event.
           this._impl.peerIdentity = msg.identity;
           this._resolvePeerIdentity(Cu.cloneInto({
             idp: this._remoteIdp.provider,
             name: msg.identity
           }, this._win));
         }
-      } catch(e) {
+      } catch (e) {
         this._rejectPeerIdentity(e);
         // If we don't expect a specific peer identity, failure to get a valid
         // peer identity is not a terminal state, so replace the promise to
         // allow another attempt.
         if (!this._impl.peerIdentity) {
           this._resetPeerIdentityPromise();
         }
         throw e;
@@ -1192,17 +1192,17 @@ class RTCPeerConnection {
     }
     return new this._win.RTCSessionDescription({ type: this._remoteType, sdp });
   }
 
   get peerIdentity() { return this._peerIdentity; }
   get idpLoginUrl() { return this._localIdp.idpLoginUrl; }
   get id() { return this._impl.id; }
   set id(s) { this._impl.id = s; }
-  get iceGatheringState()  { return this._iceGatheringState; }
+  get iceGatheringState() { return this._iceGatheringState; }
   get iceConnectionState() { return this._iceConnectionState; }
 
   get signalingState() {
     // checking for our local pc closed indication
     // before invoking the pc methods.
     if (this._closed) {
       return "closed";
     }
@@ -1414,44 +1414,41 @@ class PeerConnectionObserver {
   //
   //   closed        All of the RTCIceTransports are in the closed state.
 
   handleIceConnectionStateChange(iceConnectionState) {
     let pc = this._dompc;
     if (pc.iceConnectionState === iceConnectionState) {
       return;
     }
-    if (pc.iceConnectionState === 'new') {
+    if (pc.iceConnectionState === "new") {
       var checking_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_CHECKING_RATE");
-      if (iceConnectionState === 'checking') {
+      if (iceConnectionState === "checking") {
         checking_histogram.add(true);
-      } else if (iceConnectionState === 'failed') {
+      } else if (iceConnectionState === "failed") {
         checking_histogram.add(false);
       }
-    } else if (pc.iceConnectionState === 'checking') {
+    } else if (pc.iceConnectionState === "checking") {
       var success_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_SUCCESS_RATE");
-      if (iceConnectionState === 'completed' ||
-          iceConnectionState === 'connected') {
+      if (iceConnectionState === "completed" ||
+          iceConnectionState === "connected") {
         success_histogram.add(true);
-      } else if (iceConnectionState === 'failed') {
+      } else if (iceConnectionState === "failed") {
         success_histogram.add(false);
       }
     }
 
-    if (iceConnectionState === 'failed') {
+    if (iceConnectionState === "failed") {
       if (!pc._hasStunServer) {
         pc.logError("ICE failed, add a STUN server and see about:webrtc for more details");
-      }
-      else if (!pc._hasTurnServer) {
+      } else if (!pc._hasTurnServer) {
         pc.logError("ICE failed, add a TURN server and see about:webrtc for more details");
-      }
-      else if (pc._hasTurnServer && !pc._iceGatheredRelayCandidates) {
+      } else if (pc._hasTurnServer && !pc._iceGatheredRelayCandidates) {
         pc.logError("ICE failed, your TURN server appears to be broken, see about:webrtc for more details");
-      }
-      else {
+      } else {
         pc.logError("ICE failed, see about:webrtc for more details");
       }
     }
 
     pc.changeIceConnectionState(iceConnectionState);
   }
 
   // This method is responsible for updating iceGatheringState. This
--- a/dom/media/PeerConnectionIdp.jsm
+++ b/dom/media/PeerConnectionIdp.jsm
@@ -1,341 +1,341 @@
 /* jshint moz:true, browser:true */
 /* 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/. */
 
-this.EXPORTED_SYMBOLS = ['PeerConnectionIdp'];
+this.EXPORTED_SYMBOLS = ["PeerConnectionIdp"];
 
 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
 
-Cu.import('resource://gre/modules/Services.jsm');
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'IdpSandbox',
-  'resource://gre/modules/media/IdpSandbox.jsm');
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "IdpSandbox",
+  "resource://gre/modules/media/IdpSandbox.jsm");
 
 /**
  * Creates an IdP helper.
  *
  * @param win (object) the window we are working for
  * @param timeout (int) the timeout in milliseconds
  */
 function PeerConnectionIdp(win, timeout) {
   this._win = win;
   this._timeout = timeout || 5000;
 
   this.provider = null;
   this._resetAssertion();
 }
 
 (function() {
-  PeerConnectionIdp._mLinePattern = new RegExp('^m=', 'm');
+  PeerConnectionIdp._mLinePattern = new RegExp("^m=", "m");
   // attributes are funny, the 'a' is case sensitive, the name isn't
-  let pattern = '^a=[iI][dD][eE][nN][tT][iI][tT][yY]:(\\S+)';
-  PeerConnectionIdp._identityPattern = new RegExp(pattern, 'm');
-  pattern = '^a=[fF][iI][nN][gG][eE][rR][pP][rR][iI][nN][tT]:(\\S+) (\\S+)';
-  PeerConnectionIdp._fingerprintPattern = new RegExp(pattern, 'm');
+  let pattern = "^a=[iI][dD][eE][nN][tT][iI][tT][yY]:(\\S+)";
+  PeerConnectionIdp._identityPattern = new RegExp(pattern, "m");
+  pattern = "^a=[fF][iI][nN][gG][eE][rR][pP][rR][iI][nN][tT]:(\\S+) (\\S+)";
+  PeerConnectionIdp._fingerprintPattern = new RegExp(pattern, "m");
 })();
 
 PeerConnectionIdp.prototype = {
   get enabled() {
     return !!this._idp;
   },
 
-  _resetAssertion: function() {
+  _resetAssertion() {
     this.assertion = null;
     this.idpLoginUrl = null;
   },
 
-  setIdentityProvider: function(provider, protocol, username) {
+  setIdentityProvider(provider, protocol, username) {
     this._resetAssertion();
     this.provider = provider;
-    this.protocol = protocol || 'default';
+    this.protocol = protocol || "default";
     this.username = username;
     if (this._idp) {
       if (this._idp.isSame(provider, protocol)) {
         return; // noop
       }
       this._idp.stop();
     }
     this._idp = new IdpSandbox(provider, protocol, this._win);
   },
 
   // start the IdP and do some error fixup
-  start: function() {
+  start() {
     return this._idp.start()
       .catch(e => {
-        throw new this._win.DOMException(e.message, 'IdpError');
+        throw new this._win.DOMException(e.message, "IdpError");
       });
   },
 
-  close: function() {
+  close() {
     this._resetAssertion();
     this.provider = null;
     this.protocol = null;
     if (this._idp) {
       this._idp.stop();
       this._idp = null;
     }
   },
 
-  _getFingerprintsFromSdp: function(sdp) {
+  _getFingerprintsFromSdp(sdp) {
     let fingerprints = {};
     let m = sdp.match(PeerConnectionIdp._fingerprintPattern);
     while (m) {
       fingerprints[m[0]] = { algorithm: m[1], digest: m[2] };
       sdp = sdp.substring(m.index + m[0].length);
       m = sdp.match(PeerConnectionIdp._fingerprintPattern);
     }
 
     return Object.keys(fingerprints).map(k => fingerprints[k]);
   },
 
-  _isValidAssertion: function(assertion) {
+  _isValidAssertion(assertion) {
     return assertion && assertion.idp &&
-      typeof assertion.idp.domain === 'string' &&
+      typeof assertion.idp.domain === "string" &&
       (!assertion.idp.protocol ||
-       typeof assertion.idp.protocol === 'string') &&
-      typeof assertion.assertion === 'string';
+       typeof assertion.idp.protocol === "string") &&
+      typeof assertion.assertion === "string";
   },
 
-  _getIdentityFromSdp: function(sdp) {
+  _getIdentityFromSdp(sdp) {
     // a=identity is session level
     let idMatch;
     let mLineMatch = sdp.match(PeerConnectionIdp._mLinePattern);
     if (mLineMatch) {
       let sessionLevel = sdp.substring(0, mLineMatch.index);
       idMatch = sessionLevel.match(PeerConnectionIdp._identityPattern);
     }
     if (!idMatch) {
       return; // undefined === no identity
     }
 
     let assertion;
     try {
       assertion = JSON.parse(atob(idMatch[1]));
     } catch (e) {
-      throw new this._win.DOMException('invalid identity assertion: ' + e,
-                                       'InvalidSessionDescriptionError');
+      throw new this._win.DOMException("invalid identity assertion: " + e,
+                                       "InvalidSessionDescriptionError");
     }
     if (!this._isValidAssertion(assertion)) {
-      throw new this._win.DOMException('assertion missing idp/idp.domain/assertion',
-                                       'InvalidSessionDescriptionError');
+      throw new this._win.DOMException("assertion missing idp/idp.domain/assertion",
+                                       "InvalidSessionDescriptionError");
     }
     return assertion;
   },
 
   /**
    * Verifies the a=identity line the given SDP contains, if any.
    * If the verification succeeds callback is called with the message from the
    * IdP proxy as parameter, else (verification failed OR no a=identity line in
    * SDP at all) null is passed to callback.
    *
    * Note that this only verifies that the SDP is coherent.  We still rely on
    * the fact that the RTCPeerConnection won't connect to a peer if the
    * fingerprint of the certificate they offer doesn't appear in the SDP.
    */
-  verifyIdentityFromSDP: function(sdp, origin) {
+  verifyIdentityFromSDP(sdp, origin) {
     let identity = this._getIdentityFromSdp(sdp);
     let fingerprints = this._getFingerprintsFromSdp(sdp);
     if (!identity || fingerprints.length <= 0) {
       return this._win.Promise.resolve(); // undefined result = no identity
     }
 
     this.setIdentityProvider(identity.idp.domain, identity.idp.protocol);
     return this._verifyIdentity(identity.assertion, fingerprints, origin);
   },
 
   /**
    * Checks that the name in the identity provided by the IdP is OK.
    *
    * @param name (string) the name to validate
    * @throws if the name isn't valid
    */
-  _validateName: function(name) {
+  _validateName(name) {
     let error = msg => {
-        throw new this._win.DOMException('assertion name error: ' + msg,
-                                         'IdpError');
+        throw new this._win.DOMException("assertion name error: " + msg,
+                                         "IdpError");
     };
 
-    if (typeof name !== 'string') {
-      error('name not a string');
+    if (typeof name !== "string") {
+      error("name not a string");
     }
-    let atIdx = name.indexOf('@');
+    let atIdx = name.indexOf("@");
     if (atIdx <= 0) {
-      error('missing authority in name from IdP');
+      error("missing authority in name from IdP");
     }
 
     // no third party assertions... for now
     let tail = name.substring(atIdx + 1);
 
     // strip the port number, if present
     let provider = this.provider;
-    let providerPortIdx = provider.indexOf(':');
+    let providerPortIdx = provider.indexOf(":");
     if (providerPortIdx > 0) {
       provider = provider.substring(0, providerPortIdx);
     }
-    let idnService = Components.classes['@mozilla.org/network/idn-service;1']
+    let idnService = Components.classes["@mozilla.org/network/idn-service;1"]
         .getService(Components.interfaces.nsIIDNService);
     if (idnService.convertUTF8toACE(tail) !==
         idnService.convertUTF8toACE(provider)) {
       error('name "' + name +
             '" doesn\'t match IdP: "' + this.provider + '"');
     }
   },
 
   /**
    * Check the validation response.  We are very defensive here when handling
    * the message from the IdP proxy.  That way, broken IdPs aren't likely to
    * cause catastrophic damage.
    */
-  _checkValidation: function(validation, sdpFingerprints) {
+  _checkValidation(validation, sdpFingerprints) {
     let error = msg => {
-      throw new this._win.DOMException('IdP validation error: ' + msg,
-                                       'IdpError');
+      throw new this._win.DOMException("IdP validation error: " + msg,
+                                       "IdpError");
     };
 
     if (!this.provider) {
-      error('IdP closed');
+      error("IdP closed");
     }
 
-    if (typeof validation !== 'object' ||
-        typeof validation.contents !== 'string' ||
-        typeof validation.identity !== 'string') {
-      error('no payload in validation response');
+    if (typeof validation !== "object" ||
+        typeof validation.contents !== "string" ||
+        typeof validation.identity !== "string") {
+      error("no payload in validation response");
     }
 
     let fingerprints;
     try {
       fingerprints = JSON.parse(validation.contents).fingerprint;
     } catch (e) {
-      error('invalid JSON');
+      error("invalid JSON");
     }
 
     let isFingerprint = f =>
-        (typeof f.digest === 'string') &&
-        (typeof f.algorithm === 'string');
+        (typeof f.digest === "string") &&
+        (typeof f.algorithm === "string");
     if (!Array.isArray(fingerprints) || !fingerprints.every(isFingerprint)) {
-      error('fingerprints must be an array of objects' +
-            ' with digest and algorithm attributes');
+      error("fingerprints must be an array of objects" +
+            " with digest and algorithm attributes");
     }
 
     // everything in `innerSet` is found in `outerSet`
     let isSubsetOf = (outerSet, innerSet, comparator) => {
       return innerSet.every(i => {
         return outerSet.some(o => comparator(i, o));
       });
     };
     let compareFingerprints = (a, b) => {
       return (a.digest === b.digest) && (a.algorithm === b.algorithm);
     };
     if (!isSubsetOf(fingerprints, sdpFingerprints, compareFingerprints)) {
-      error('the fingerprints must be covered by the assertion');
+      error("the fingerprints must be covered by the assertion");
     }
     this._validateName(validation.identity);
     return validation;
   },
 
   /**
    * Asks the IdP proxy to verify an identity assertion.
    */
-  _verifyIdentity: function(assertion, fingerprints, origin) {
+  _verifyIdentity(assertion, fingerprints, origin) {
     let p = this.start()
         .then(idp => this._wrapCrossCompartmentPromise(
           idp.validateAssertion(assertion, origin)))
         .then(validation => this._checkValidation(validation, fingerprints));
 
     return this._applyTimeout(p);
   },
 
   /**
    * Enriches the given SDP with an `a=identity` line.  getIdentityAssertion()
    * must have already run successfully, otherwise this does nothing to the sdp.
    */
-  addIdentityAttribute: function(sdp) {
+  addIdentityAttribute(sdp) {
     if (!this.assertion) {
       return sdp;
     }
 
     // yes, we assume that this matches; if it doesn't something is *wrong*
     let match = sdp.match(PeerConnectionIdp._mLinePattern);
     return sdp.substring(0, match.index) +
-      'a=identity:' + this.assertion + '\r\n' +
+      "a=identity:" + this.assertion + "\r\n" +
       sdp.substring(match.index);
   },
 
   /**
    * Asks the IdP proxy for an identity assertion.  Don't call this unless you
    * have checked .enabled, or you really like exceptions.  Also, don't call
    * this when another call is still running, because it's not certain which
    * call will finish first and the final state will be similarly uncertain.
    */
-  getIdentityAssertion: function(fingerprint, origin) {
+  getIdentityAssertion(fingerprint, origin) {
     if (!this.enabled) {
       throw new this._win.DOMException(
-        'no IdP set, call setIdentityProvider() to set one', 'InvalidStateError');
+        "no IdP set, call setIdentityProvider() to set one", "InvalidStateError");
     }
 
-    let [algorithm, digest] = fingerprint.split(' ', 2);
+    let [algorithm, digest] = fingerprint.split(" ", 2);
     let content = {
       fingerprint: [{
-        algorithm: algorithm,
-        digest: digest
+        algorithm,
+        digest
       }]
     };
 
     this._resetAssertion();
     let p = this.start()
         .then(idp => this._wrapCrossCompartmentPromise(
           idp.generateAssertion(JSON.stringify(content),
                                 origin, this.username)))
         .then(assertion => {
           if (!this._isValidAssertion(assertion)) {
-            throw new this._win.DOMException('IdP generated invalid assertion',
-                                             'IdpError');
+            throw new this._win.DOMException("IdP generated invalid assertion",
+                                             "IdpError");
           }
           // save the base64+JSON assertion, since that is all that is used
           this.assertion = btoa(JSON.stringify(assertion));
           return this.assertion;
         });
 
     return this._applyTimeout(p);
   },
 
   /**
    * Promises generated by the sandbox need to be very carefully treated so that
    * they can chain into promises in the `this._win` compartment.  Results need
    * to be cloned across; errors need to be converted.
    */
-  _wrapCrossCompartmentPromise: function(sandboxPromise) {
+  _wrapCrossCompartmentPromise(sandboxPromise) {
     return new this._win.Promise((resolve, reject) => {
       sandboxPromise.then(
         result => resolve(Cu.cloneInto(result, this._win)),
         e => {
-          let message = '' + (e.message || JSON.stringify(e) || 'IdP error');
-          if (e.name === 'IdpLoginError') {
-            if (typeof e.loginUrl === 'string') {
+          let message = "" + (e.message || JSON.stringify(e) || "IdP error");
+          if (e.name === "IdpLoginError") {
+            if (typeof e.loginUrl === "string") {
               this.idpLoginUrl = e.loginUrl;
             }
-            reject(new this._win.DOMException(message, 'IdpLoginError'));
+            reject(new this._win.DOMException(message, "IdpLoginError"));
           } else {
-            reject(new this._win.DOMException(message, 'IdpError'));
+            reject(new this._win.DOMException(message, "IdpError"));
           }
         });
     });
   },
 
   /**
    * Wraps a promise, adding a timeout guard on it so that it can't take longer
    * than the specified time.  Returns a promise that rejects if the timeout
    * elapses before `p` resolves.
    */
-  _applyTimeout: function(p) {
+  _applyTimeout(p) {
     let timeout = new this._win.Promise(
       r => this._win.setTimeout(r, this._timeout))
         .then(() => {
-          throw new this._win.DOMException('IdP timed out', 'IdpError');
+          throw new this._win.DOMException("IdP timed out", "IdpError");
         });
     return this._win.Promise.race([ timeout, p ]);
   }
 };
 
 this.PeerConnectionIdp = PeerConnectionIdp;