--- a/browser/base/content/test/static/browser_parsable_css.js
+++ b/browser/base/content/test/static/browser_parsable_css.js
@@ -20,17 +20,17 @@ let whitelist = [
    {sourceName: /devtools-client-shared\/components\/reps\/reps.css/i,
    isFromDevTools: true},
   // PDFjs is futureproofing its pseudoselectors, and those rules are dropped.
   {sourceName: /web\/viewer\.css$/i,
    errorMessage: /Unknown pseudo-class.*(fullscreen|selection)/i,
    isFromDevTools: false},
   // PDFjs rules needed for compat with other UAs.
   {sourceName: /web\/viewer\.css$/i,
-   errorMessage: /Unknown property.*appearance/i,
+   errorMessage: /Unknown property.*(appearance|user-select)/i,
    isFromDevTools: false},
   // Highlighter CSS uses a UA-only pseudo-class, see bug 985597.
   {sourceName: /highlighters\.css$/i,
    errorMessage: /Unknown pseudo-class.*moz-native-anonymous/i,
    isFromDevTools: true},
   // Responsive Design Mode CSS uses a UA-only pseudo-class, see Bug 1241714.
   {sourceName: /responsive-ua\.css$/i,
    errorMessage: /Unknown pseudo-class.*moz-dropdown-list/i,

--- a/browser/extensions/pdfjs/README.mozilla
+++ b/browser/extensions/pdfjs/README.mozilla
@@ -1,5 +1,5 @@
 This is the PDF.js project output, https://github.com/mozilla/pdf.js
 
-Current extension version is: 2.0.480
+Current extension version is: 2.0.491
 
-Taken from upstream commit: a7a034d8
+Taken from upstream commit: 2dc4af52

--- a/browser/extensions/pdfjs/content/PdfStreamConverter.jsm
+++ b/browser/extensions/pdfjs/content/PdfStreamConverter.jsm
@@ -14,16 +14,17 @@
  */
 
 "use strict";
 
 var EXPORTED_SYMBOLS = ["PdfStreamConverter"];
 
 const PDFJS_EVENT_ID = "pdf.js.message";
 const PREF_PREFIX = "pdfjs";
+const PDF_VIEWER_ORIGIN = "resource://pdf.js";
 const PDF_VIEWER_WEB_PAGE = "resource://pdf.js/web/viewer.html";
 const MAX_NUMBER_OF_PREFS = 50;
 const MAX_STRING_PREF_LENGTH = 128;
 
 ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 
 ChromeUtils.defineModuleGetter(this, "NetUtil",
@@ -76,21 +77,25 @@ function log(aMsg) {
   if (!getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false)) {
     return;
   }
   var msg = "PdfStreamConverter.js: " + (aMsg.join ? aMsg.join("") : aMsg);
   Services.console.logStringMessage(msg);
   dump(msg + "\n");
 }
 
-function getDOMWindow(aChannel) {
+function getDOMWindow(aChannel, aPrincipal) {
   var requestor = aChannel.notificationCallbacks ?
                   aChannel.notificationCallbacks :
                   aChannel.loadGroup.notificationCallbacks;
   var win = requestor.getInterface(Ci.nsIDOMWindow);
+  // Ensure the window wasn't navigated to something that is not PDF.js.
+  if (!win.document.nodePrincipal.equals(aPrincipal)) {
+    return null;
+  }
   return win;
 }
 
 function getLocalizedStrings(path) {
   var stringBundle =
     Services.strings.createBundle("chrome://pdf.js/locale/" + path);
 
   var map = {};
@@ -590,31 +595,31 @@ class RangedChromeActions extends Chrome
       data = this.dataListener.readData();
 
       this.dataListener.onprogress = (loaded, total) => {
         this.domWindow.postMessage({
           pdfjsLoadAction: "progressiveRead",
           loaded,
           total,
           chunk: this.dataListener.readData(),
-        }, "*");
+        }, PDF_VIEWER_ORIGIN);
       };
       this.dataListener.oncomplete = () => {
         this.dataListener = null;
       };
     }
 
     this.domWindow.postMessage({
       pdfjsLoadAction: "supportsRangedLoading",
       rangeEnabled: this.rangeEnabled,
       streamingEnabled: this.streamingEnabled,
       pdfUrl: this.pdfUrl,
       length: this.contentLength,
       data,
-    }, "*");
+    }, PDF_VIEWER_ORIGIN);
 
     return true;
   }
 
   requestDataRange(args) {
     if (!this.rangeEnabled) {
       return;
     }
@@ -626,23 +631,23 @@ class RangedChromeActions extends Chrome
     // errors from chrome code for non-range requests, so this doesn't
     // seem high-pri
     this.networkManager.requestRange(begin, end, {
       onDone: function RangedChromeActions_onDone(aArgs) {
         domWindow.postMessage({
           pdfjsLoadAction: "range",
           begin: aArgs.begin,
           chunk: aArgs.chunk,
-        }, "*");
+        }, PDF_VIEWER_ORIGIN);
       },
       onProgress: function RangedChromeActions_onProgress(evt) {
         domWindow.postMessage({
           pdfjsLoadAction: "rangeProgress",
           loaded: evt.loaded,
-        }, "*");
+        }, PDF_VIEWER_ORIGIN);
       },
     });
   }
 
   abortLoading() {
     this.networkManager.abortAllRequests();
     if (this.originalRequest) {
       this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
@@ -668,25 +673,25 @@ class StandardChromeActions extends Chro
       return false;
     }
 
     this.dataListener.onprogress = (loaded, total) => {
       this.domWindow.postMessage({
         pdfjsLoadAction: "progress",
         loaded,
         total,
-      }, "*");
+      }, PDF_VIEWER_ORIGIN);
     };
 
     this.dataListener.oncomplete = (data, errorCode) => {
       this.domWindow.postMessage({
         pdfjsLoadAction: "complete",
         data,
         errorCode,
-      }, "*");
+      }, PDF_VIEWER_ORIGIN);
 
       this.dataListener = null;
       this.originalRequest = null;
     };
 
     return true;
   }
 
@@ -934,30 +939,34 @@ PdfStreamConverter.prototype = {
       onStartRequest(request, context) {
         listener.onStartRequest(aRequest, aContext);
       },
       onDataAvailable(request, context, inputStream, offset, count) {
         listener.onDataAvailable(aRequest, aContext, inputStream,
                                  offset, count);
       },
       onStopRequest(request, context, statusCode) {
-        // We get the DOM window here instead of before the request since it
-        // may have changed during a redirect.
-        var domWindow = getDOMWindow(channel);
+        var domWindow = getDOMWindow(channel, resourcePrincipal);
+        if (!Components.isSuccessCode(statusCode) || !domWindow) {
+          // The request may have been aborted and the document may have been
+          // replaced with something that is not PDF.js, abort attaching.
+          listener.onStopRequest(aRequest, context, statusCode);
+          return;
+        }
         var actions;
         if (rangeRequest || streamRequest) {
           actions = new RangedChromeActions(
             domWindow, contentDispositionFilename, aRequest,
             rangeRequest, streamRequest, dataListener);
         } else {
           actions = new StandardChromeActions(
             domWindow, contentDispositionFilename, aRequest, dataListener);
         }
         var requestListener = new RequestListener(actions);
-        domWindow.addEventListener(PDFJS_EVENT_ID, function(event) {
+        domWindow.document.addEventListener(PDFJS_EVENT_ID, function(event) {
           requestListener.receive(event);
         }, false, true);
         if (actions.supportsIntegratedFind()) {
           var findEventManager = new FindEventManager(domWindow);
           findEventManager.bind();
         }
         listener.onStopRequest(aRequest, aContext, statusCode);
 

--- a/browser/extensions/pdfjs/content/build/pdf.js
+++ b/browser/extensions/pdfjs/content/build/pdf.js
@@ -1645,18 +1645,18 @@ exports.GlobalWorkerOptions = GlobalWork
 
 /***/ }),
 /* 5 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
-var pdfjsVersion = '2.0.480';
-var pdfjsBuild = 'a7a034d8';
+var pdfjsVersion = '2.0.491';
+var pdfjsBuild = '2dc4af52';
 var pdfjsSharedUtil = __w_pdfjs_require__(0);
 var pdfjsDisplayAPI = __w_pdfjs_require__(9);
 var pdfjsDisplayTextLayer = __w_pdfjs_require__(17);
 var pdfjsDisplayAnnotationLayer = __w_pdfjs_require__(18);
 var pdfjsDisplayDOMUtils = __w_pdfjs_require__(1);
 var pdfjsDisplaySVG = __w_pdfjs_require__(19);
 let pdfjsDisplayWorkerOptions = __w_pdfjs_require__(4);
 let pdfjsDisplayAPICompatibility = __w_pdfjs_require__(3);
@@ -4924,17 +4924,17 @@ function _fetchDocument(worker, source, 
     return Promise.reject(new Error('Worker was destroyed'));
   }
   if (pdfDataRangeTransport) {
     source.length = pdfDataRangeTransport.length;
     source.initialData = pdfDataRangeTransport.initialData;
   }
   return worker.messageHandler.sendWithPromise('GetDocRequest', {
     docId,
-    apiVersion: '2.0.480',
+    apiVersion: '2.0.491',
     source: {
       data: source.data,
       url: source.url,
       password: source.password,
       disableAutoFetch: source.disableAutoFetch,
       rangeChunkSize: source.rangeChunkSize,
       length: source.length
     },
@@ -6247,18 +6247,18 @@ var InternalRenderTask = function Intern
         }
       }
     }
   };
   return InternalRenderTask;
 }();
 var version, build;
 {
-  exports.version = version = '2.0.480';
-  exports.build = build = 'a7a034d8';
+  exports.version = version = '2.0.491';
+  exports.build = build = '2dc4af52';
 }
 exports.getDocument = getDocument;
 exports.LoopbackPort = LoopbackPort;
 exports.PDFDataRangeTransport = PDFDataRangeTransport;
 exports.PDFWorker = PDFWorker;
 exports.PDFDocumentProxy = PDFDocumentProxy;
 exports.PDFPageProxy = PDFPageProxy;
 exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;

--- a/browser/extensions/pdfjs/content/build/pdf.worker.js
+++ b/browser/extensions/pdfjs/content/build/pdf.worker.js
@@ -2753,19 +2753,19 @@ var ColorSpace = function ColorSpaceClos
           }
         }
       }
     },
     usesZeroToOneRange: true
   };
   ColorSpace.parse = function (cs, xref, res, pdfFunctionFactory) {
     let IR = ColorSpace.parseToIR(cs, xref, res, pdfFunctionFactory);
-    return ColorSpace.fromIR(IR, pdfFunctionFactory);
-  };
-  ColorSpace.fromIR = function (IR, pdfFunctionFactory) {
+    return ColorSpace.fromIR(IR);
+  };
+  ColorSpace.fromIR = function (IR) {
     var name = Array.isArray(IR) ? IR[0] : IR;
     var whitePoint, blackPoint, gamma;
     switch (name) {
       case 'DeviceGrayCS':
         return this.singletons.gray;
       case 'DeviceRgbCS':
         return this.singletons.rgb;
       case 'DeviceCmykCS':
@@ -2779,29 +2779,29 @@ var ColorSpace = function ColorSpaceClos
         whitePoint = IR[1];
         blackPoint = IR[2];
         gamma = IR[3];
         var matrix = IR[4];
         return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
       case 'PatternCS':
         var basePatternCS = IR[1];
         if (basePatternCS) {
-          basePatternCS = ColorSpace.fromIR(basePatternCS, pdfFunctionFactory);
+          basePatternCS = ColorSpace.fromIR(basePatternCS);
         }
         return new PatternCS(basePatternCS);
       case 'IndexedCS':
         var baseIndexedCS = IR[1];
         var hiVal = IR[2];
         var lookup = IR[3];
-        return new IndexedCS(ColorSpace.fromIR(baseIndexedCS, pdfFunctionFactory), hiVal, lookup);
+        return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup);
       case 'AlternateCS':
         var numComps = IR[1];
         var alt = IR[2];
-        var tintFnIR = IR[3];
-        return new AlternateCS(numComps, ColorSpace.fromIR(alt, pdfFunctionFactory), pdfFunctionFactory.createFromIR(tintFnIR));
+        var tintFn = IR[3];
+        return new AlternateCS(numComps, ColorSpace.fromIR(alt), tintFn);
       case 'LabCS':
         whitePoint = IR[1];
         blackPoint = IR[2];
         var range = IR[3];
         return new LabCS(whitePoint, blackPoint, range);
       default:
         throw new _util.FormatError(`Unknown colorspace name: ${name}`);
     }
@@ -2900,18 +2900,18 @@ var ColorSpace = function ColorSpaceClos
             lookup = lookup.getBytes();
           }
           return ['IndexedCS', baseIndexedCS, hiVal, lookup];
         case 'Separation':
         case 'DeviceN':
           var name = xref.fetchIfRef(cs[1]);
           numComps = Array.isArray(name) ? name.length : 1;
           alt = ColorSpace.parseToIR(cs[2], xref, res, pdfFunctionFactory);
-          let tintFnIR = pdfFunctionFactory.createIR(xref.fetchIfRef(cs[3]));
-          return ['AlternateCS', numComps, alt, tintFnIR];
+          let tintFn = pdfFunctionFactory.create(xref.fetchIfRef(cs[3]));
+          return ['AlternateCS', numComps, alt, tintFn];
         case 'Lab':
           params = xref.fetchIfRef(cs[1]);
           whitePoint = params.getArray('WhitePoint');
           blackPoint = params.getArray('BlackPoint');
           var range = params.getArray('Range');
           return ['LabCS', whitePoint, blackPoint, range];
         default:
           throw new _util.FormatError(`unimplemented color space object "${mode}"`);
@@ -20086,30 +20086,32 @@ class PDFFunctionFactory {
   }
   createFromArray(fnObj) {
     return PDFFunction.parseArray({
       xref: this.xref,
       isEvalSupported: this.isEvalSupported,
       fnObj
     });
   }
-  createFromIR(IR) {
-    return PDFFunction.fromIR({
-      xref: this.xref,
-      isEvalSupported: this.isEvalSupported,
-      IR
-    });
-  }
-  createIR(fn) {
-    return PDFFunction.getIR({
-      xref: this.xref,
-      isEvalSupported: this.isEvalSupported,
-      fn
-    });
-  }
+}
+function toNumberArray(arr) {
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  const length = arr.length;
+  for (let i = 0; i < length; i++) {
+    if (typeof arr[i] !== 'number') {
+      const result = new Array(length);
+      for (let i = 0; i < length; i++) {
+        result[i] = +arr[i];
+      }
+      return result;
+    }
+  }
+  return arr;
 }
 var PDFFunction = function PDFFunctionClosure() {
   const CONSTRUCT_SAMPLED = 0;
   const CONSTRUCT_INTERPOLATED = 2;
   const CONSTRUCT_STICHED = 3;
   const CONSTRUCT_POSTSCRIPT = 4;
   return {
     getSampleArray(size, outputSize, bps, stream) {
@@ -20224,41 +20226,41 @@ var PDFFunction = function PDFFunctionCl
         var out = [];
         var index = 0;
         for (var i = 0; i < inputLength; i += 2) {
           out[index] = [arr[i], arr[i + 1]];
           ++index;
         }
         return out;
       }
-      var domain = dict.getArray('Domain');
-      var range = dict.getArray('Range');
+      var domain = toNumberArray(dict.getArray('Domain'));
+      var range = toNumberArray(dict.getArray('Range'));
       if (!domain || !range) {
         throw new _util.FormatError('No domain or range');
       }
       var inputSize = domain.length / 2;
       var outputSize = range.length / 2;
       domain = toMultiArray(domain);
       range = toMultiArray(range);
-      var size = dict.get('Size');
+      var size = toNumberArray(dict.get('Size'));
       var bps = dict.get('BitsPerSample');
       var order = dict.get('Order') || 1;
       if (order !== 1) {
         (0, _util.info)('No support for cubic spline interpolation: ' + order);
       }
-      var encode = dict.getArray('Encode');
+      var encode = toNumberArray(dict.getArray('Encode'));
       if (!encode) {
         encode = [];
         for (var i = 0; i < inputSize; ++i) {
-          encode.push(0);
-          encode.push(size[i] - 1);
-        }
-      }
-      encode = toMultiArray(encode);
-      var decode = dict.getArray('Decode');
+          encode.push([0, size[i] - 1]);
+        }
+      } else {
+        encode = toMultiArray(encode);
+      }
+      var decode = toNumberArray(dict.getArray('Decode'));
       if (!decode) {
         decode = range;
       } else {
         decode = toMultiArray(decode);
       }
       var samples = this.getSampleArray(size, outputSize, bps, fn);
       return [CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size, outputSize, Math.pow(2, bps) - 1, range];
     },
@@ -20314,22 +20316,19 @@ var PDFFunction = function PDFFunctionCl
             rj += samples[cubeVertex[i] + j] * cubeN[i];
           }
           rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
           dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
         }
       };
     },
     constructInterpolated({ xref, isEvalSupported, fn, dict }) {
-      var c0 = dict.getArray('C0') || [0];
-      var c1 = dict.getArray('C1') || [1];
+      var c0 = toNumberArray(dict.getArray('C0')) || [0];
+      var c1 = toNumberArray(dict.getArray('C1')) || [1];
       var n = dict.get('N');
-      if (!Array.isArray(c0) || !Array.isArray(c1)) {
-        throw new _util.FormatError('Illegal dictionary for interpolated function');
-      }
       var length = c0.length;
       var diff = [];
       for (var i = 0; i < length; ++i) {
         diff.push(c1[i] - c0[i]);
       }
       return [CONSTRUCT_INTERPOLATED, c0, diff, n];
     },
     constructInterpolatedFromIR({ xref, isEvalSupported, IR }) {
@@ -20340,51 +20339,43 @@ var PDFFunction = function PDFFunctionCl
       return function constructInterpolatedFromIRResult(src, srcOffset, dest, destOffset) {
         var x = n === 1 ? src[srcOffset] : Math.pow(src[srcOffset], n);
         for (var j = 0; j < length; ++j) {
           dest[destOffset + j] = c0[j] + x * diff[j];
         }
       };
     },
     constructStiched({ xref, isEvalSupported, fn, dict }) {
-      var domain = dict.getArray('Domain');
+      var domain = toNumberArray(dict.getArray('Domain'));
       if (!domain) {
         throw new _util.FormatError('No domain');
       }
       var inputSize = domain.length / 2;
       if (inputSize !== 1) {
         throw new _util.FormatError('Bad domain for stiched function');
       }
       var fnRefs = dict.get('Functions');
       var fns = [];
       for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
-        fns.push(this.getIR({
+        fns.push(this.parse({
           xref,
           isEvalSupported,
           fn: xref.fetchIfRef(fnRefs[i])
         }));
       }
-      var bounds = dict.getArray('Bounds');
-      var encode = dict.getArray('Encode');
+      var bounds = toNumberArray(dict.getArray('Bounds'));
+      var encode = toNumberArray(dict.getArray('Encode'));
       return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
     },
     constructStichedFromIR({ xref, isEvalSupported, IR }) {
       var domain = IR[1];
       var bounds = IR[2];
       var encode = IR[3];
-      var fnsIR = IR[4];
-      var fns = [];
+      var fns = IR[4];
       var tmpBuf = new Float32Array(1);
-      for (var i = 0, ii = fnsIR.length; i < ii; i++) {
-        fns.push(this.fromIR({
-          xref,
-          isEvalSupported,
-          IR: fnsIR[i]
-        }));
-      }
       return function constructStichedFromIRResult(src, srcOffset, dest, destOffset) {
         var clip = function constructStichedFromIRClip(v, min, max) {
           if (v > max) {
             v = max;
           } else if (v < min) {
             v = min;
           }
           return v;
@@ -20405,18 +20396,18 @@ var PDFFunction = function PDFFunctionCl
         }
         var rmin = encode[2 * i];
         var rmax = encode[2 * i + 1];
         tmpBuf[0] = dmin === dmax ? rmin : rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);
         fns[i](tmpBuf, 0, dest, destOffset);
       };
     },
     constructPostScript({ xref, isEvalSupported, fn, dict }) {
-      var domain = dict.getArray('Domain');
-      var range = dict.getArray('Range');
+      var domain = toNumberArray(dict.getArray('Domain'));
+      var range = toNumberArray(dict.getArray('Range'));
       if (!domain) {
         throw new _util.FormatError('No domain.');
       }
       if (!range) {
         throw new _util.FormatError('No range.');
       }
       var lexer = new _ps_parser.PostScriptLexer(fn);
       var parser = new _ps_parser.PostScriptParser(lexer);
@@ -21107,18 +21098,18 @@ exports.PostScriptCompiler = PostScriptC
 
 /***/ }),
 /* 19 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
-var pdfjsVersion = '2.0.480';
-var pdfjsBuild = 'a7a034d8';
+var pdfjsVersion = '2.0.491';
+var pdfjsBuild = '2dc4af52';
 var pdfjsCoreWorker = __w_pdfjs_require__(20);
 exports.WorkerMessageHandler = pdfjsCoreWorker.WorkerMessageHandler;
 
 /***/ }),
 /* 20 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -21309,17 +21300,17 @@ var WorkerMessageHandler = {
     });
   },
   createDocumentHandler(docParams, port) {
     var pdfManager;
     var terminated = false;
     var cancelXHRs = null;
     var WorkerTasks = [];
     let apiVersion = docParams.apiVersion;
-    let workerVersion = '2.0.480';
+    let workerVersion = '2.0.491';
     if (apiVersion !== null && apiVersion !== workerVersion) {
       throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
     }
     var docId = docParams.docId;
     var docBaseUrl = docParams.docBaseUrl;
     var workerHandlerName = docParams.docId + '_worker';
     var handler = new _util.MessageHandler(workerHandlerName, docId, port);
     handler.postMessageTransfers = docParams.postMessageTransfers;
@@ -35126,17 +35117,20 @@ var FontRendererFactory = function FontR
   }
   function parseCff(data, start, end, seacAnalysisEnabled) {
     var properties = {};
     var parser = new _cff_parser.CFFParser(new _stream.Stream(data, start, end - start), properties, seacAnalysisEnabled);
     var cff = parser.parse();
     return {
       glyphs: cff.charStrings.objects,
       subrs: cff.topDict.privateDict && cff.topDict.privateDict.subrsIndex && cff.topDict.privateDict.subrsIndex.objects,
-      gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects
+      gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects,
+      isCFFCIDFont: cff.isCIDFont,
+      fdSelect: cff.fdSelect,
+      fdArray: cff.fdArray
     };
   }
   function parseGlyfTable(glyf, loca, isGlyphLocationsLong) {
     var itemSize, itemDecode;
     if (isGlyphLocationsLong) {
       itemSize = 4;
       itemDecode = function fontItemDecodeLong(data, offset) {
         return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
@@ -35330,17 +35324,17 @@ var FontRendererFactory = function FontR
           } else {
             quadraticCurveTo(contour[j].x, contour[j].y, (contour[j].x + contour[j + 1].x) / 2, (contour[j].y + contour[j + 1].y) / 2);
           }
         }
         startPoint = endPoint + 1;
       }
     }
   }
-  function compileCharString(code, cmds, font) {
+  function compileCharString(code, cmds, font, glyphId) {
     var stack = [];
     var x = 0,
         y = 0;
     var stems = 0;
     function moveTo(x, y) {
       cmds.push({
         cmd: 'moveTo',
         args: [x, y]
@@ -35414,18 +35408,37 @@ var FontRendererFactory = function FontR
               xb = xa + stack.shift();
               yb = ya + stack.shift();
               x = xb + stack.shift();
               y = yb + stack.shift();
               bezierCurveTo(xa, ya, xb, yb, x, y);
             }
             break;
           case 10:
-            n = stack.pop() + font.subrsBias;
-            subrCode = font.subrs[n];
+            n = stack.pop();
+            subrCode = null;
+            if (font.isCFFCIDFont) {
+              let fdIndex = font.fdSelect.getFDIndex(glyphId);
+              if (fdIndex >= 0 && fdIndex < font.fdArray.length) {
+                let fontDict = font.fdArray[fdIndex],
+                    subrs;
+                if (fontDict.privateDict && fontDict.privateDict.subrsIndex) {
+                  subrs = fontDict.privateDict.subrsIndex.objects;
+                }
+                if (subrs) {
+                  let numSubrs = subrs.length;
+                  n += numSubrs < 1240 ? 107 : numSubrs < 33900 ? 1131 : 32768;
+                  subrCode = subrs[n];
+                }
+              } else {
+                (0, _util.warn)('Invalid fd index for glyph index.');
+              }
+            } else {
+              subrCode = font.subrs[n + font.subrsBias];
+            }
             if (subrCode) {
               parse(subrCode);
             }
             break;
           case 11:
             return;
           case 12:
             v = code[i++];
@@ -35505,20 +35518,20 @@ var FontRendererFactory = function FontR
               y = stack.pop();
               x = stack.pop();
               cmds.push({ cmd: 'save' });
               cmds.push({
                 cmd: 'translate',
                 args: [x, y]
               });
               var cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[_encodings.StandardEncoding[achar]]));
-              compileCharString(font.glyphs[cmap.glyphId], cmds, font);
+              compileCharString(font.glyphs[cmap.glyphId], cmds, font, cmap.glyphId);
               cmds.push({ cmd: 'restore' });
               cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[_encodings.StandardEncoding[bchar]]));
-              compileCharString(font.glyphs[cmap.glyphId], cmds, font);
+              compileCharString(font.glyphs[cmap.glyphId], cmds, font, cmap.glyphId);
             }
             return;
           case 18:
             stems += stack.length >> 1;
             stackClean = true;
             break;
           case 19:
             stems += stack.length >> 1;
@@ -35683,39 +35696,49 @@ var FontRendererFactory = function FontR
     this.compiledCharCodeToGlyphId = Object.create(null);
     this.fontMatrix = fontMatrix;
   }
   CompiledFont.prototype = {
     getPathJs(unicode) {
       var cmap = lookupCmap(this.cmap, unicode);
       var fn = this.compiledGlyphs[cmap.glyphId];
       if (!fn) {
-        fn = this.compileGlyph(this.glyphs[cmap.glyphId]);
+        fn = this.compileGlyph(this.glyphs[cmap.glyphId], cmap.glyphId);
         this.compiledGlyphs[cmap.glyphId] = fn;
       }
       if (this.compiledCharCodeToGlyphId[cmap.charCode] === undefined) {
         this.compiledCharCodeToGlyphId[cmap.charCode] = cmap.glyphId;
       }
       return fn;
     },
-    compileGlyph(code) {
+    compileGlyph(code, glyphId) {
       if (!code || code.length === 0 || code[0] === 14) {
         return noop;
       }
+      let fontMatrix = this.fontMatrix;
+      if (this.isCFFCIDFont) {
+        let fdIndex = this.fdSelect.getFDIndex(glyphId);
+        if (fdIndex >= 0 && fdIndex < this.fdArray.length) {
+          let fontDict = this.fdArray[fdIndex];
+          fontMatrix = fontDict.getByName('FontMatrix') || _util.FONT_IDENTITY_MATRIX;
+        } else {
+          (0, _util.warn)('Invalid fd index for glyph index.');
+        }
+      }
       var cmds = [];
       cmds.push({ cmd: 'save' });
       cmds.push({
         cmd: 'transform',
-        args: this.fontMatrix.slice()
+        args: fontMatrix.slice()
       });
       cmds.push({
         cmd: 'scale',
         args: ['size', '-size']
       });
-      this.compileGlyphImpl(code, cmds);
+      this.compileGlyphImpl(code, cmds, glyphId);
       cmds.push({ cmd: 'restore' });
       return cmds;
     },
     compileGlyphImpl() {
       (0, _util.unreachable)('Children classes should implement this.');
     },
     hasBuiltPath(unicode) {
       var cmap = lookupCmap(this.cmap, unicode);
@@ -35738,20 +35761,23 @@ var FontRendererFactory = function FontR
     CompiledFont.call(this, fontMatrix);
     this.glyphs = cffInfo.glyphs;
     this.gsubrs = cffInfo.gsubrs || [];
     this.subrs = cffInfo.subrs || [];
     this.cmap = cmap;
     this.glyphNameMap = glyphNameMap || (0, _glyphlist.getGlyphsUnicode)();
     this.gsubrsBias = this.gsubrs.length < 1240 ? 107 : this.gsubrs.length < 33900 ? 1131 : 32768;
     this.subrsBias = this.subrs.length < 1240 ? 107 : this.subrs.length < 33900 ? 1131 : 32768;
+    this.isCFFCIDFont = cffInfo.isCFFCIDFont;
+    this.fdSelect = cffInfo.fdSelect;
+    this.fdArray = cffInfo.fdArray;
   }
   _util.Util.inherit(Type2Compiled, CompiledFont, {
-    compileGlyphImpl(code, cmds) {
-      compileCharString(code, cmds, this);
+    compileGlyphImpl(code, cmds, glyphId) {
+      compileCharString(code, cmds, this, glyphId);
     }
   });
   return {
     create: function FontRendererFactory_create(font, seacAnalysisEnabled) {
       var data = new Uint8Array(font.data);
       var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm;
       var numTables = getUshort(data, 4);
       for (var i = 0, p = 12; i < numTables; i++, p += 16) {

--- a/browser/extensions/pdfjs/content/web/viewer.css
+++ b/browser/extensions/pdfjs/content/web/viewer.css
@@ -24,17 +24,16 @@
   line-height: 1.0;
 }
 
 .textLayer > div {
   color: transparent;
   position: absolute;
   white-space: pre;
   cursor: text;
-  -moz-transform-origin: 0% 0%;
   transform-origin: 0% 0%;
 }
 
 .textLayer .highlight {
   margin: -1px;
   padding: 1px;
 
   background-color: rgb(180, 0, 170);
@@ -52,29 +51,31 @@
 .textLayer .highlight.middle {
   border-radius: 0px;
 }
 
 .textLayer .highlight.selected {
   background-color: rgb(0, 100, 0);
 }
 
+.textLayer ::-moz-selection { background: rgb(0,0,255); }
+
 .textLayer ::selection { background: rgb(0,0,255); }
-.textLayer ::-moz-selection { background: rgb(0,0,255); }
 
 .textLayer .endOfContent {
   display: block;
   position: absolute;
   left: 0px;
   top: 100%;
   right: 0px;
   bottom: 0px;
   z-index: -1;
   cursor: default;
   -moz-user-select: none;
+       user-select: none;
 }
 
 .textLayer .endOfContent.active {
   top: 0px;
 }
 
 
 .annotationLayer section {
@@ -204,17 +205,17 @@
    * when the element has focus and revert this when it loses focus.
    */
   width: 115%;
 }
 
 .annotationLayer .buttonWidgetAnnotation.checkBox input,
 .annotationLayer .buttonWidgetAnnotation.radioButton input {
   -moz-appearance: none;
-  appearance: none;
+       appearance: none;
   padding: 0;
 }
 
 .annotationLayer .popupWrapper {
   position: absolute;
   width: 20em;
 }
 
@@ -360,27 +361,29 @@ select {
   top: 0px;
   border-top: 2px solid transparent;
   background-color: #000;
   width: 100%;
   height: 100%;
   overflow: hidden;
   cursor: none;
   -moz-user-select: none;
+       user-select: none;
 }
 
 #viewerContainer.pdfPresentationMode:fullscreen {
   top: 0px;
   border-top: 2px solid transparent;
   background-color: #000;
   width: 100%;
   height: 100%;
   overflow: hidden;
   cursor: none;
   -moz-user-select: none;
+       user-select: none;
 }
 
 .pdfPresentationMode:-moz-full-screen a:not(.internalLink) {
   display: none;
 }
 
 .pdfPresentationMode:fullscreen a:not(.internalLink) {
   display: none;
@@ -434,16 +437,17 @@ html[dir='rtl'] #sidebarContainer {
   top: 36px;
 }
 
 #outerContainer.sidebarResizing #sidebarContainer {
   /* Improve responsiveness and avoid visual glitches when the sidebar is resized. */
   transition-duration: 0s;
   /* Prevent e.g. the thumbnails being selected when the sidebar is resized. */
   -moz-user-select: none;
+       user-select: none;
 }
 
 #outerContainer.sidebarMoving #sidebarContainer,
 #outerContainer.sidebarOpen #sidebarContainer {
   visibility: visible;
 }
 html[dir='ltr'] #outerContainer.sidebarOpen #sidebarContainer {
   left: 0px;
@@ -659,24 +663,22 @@ html[dir='ltr'] .findbar {
   left: 68px;
 }
 html[dir='rtl'] .findbar {
   right: 68px;
 }
 
 .findbar label {
   -moz-user-select: none;
+       user-select: none;
 }
 
 #findInput {
   width: 200px;
 }
-#findInput::-moz-placeholder {
-  font-style: italic;
-}
 #findInput::placeholder {
   font-style: italic;
 }
 #findInput[data-status="pending"] {
   background-image: url(images/loading-small.png);
   background-repeat: no-repeat;
   background-position: right;
 }
@@ -928,16 +930,17 @@ html[dir='rtl'] .splitToolbarButtonSepar
   min-width: 16px;
   padding: 2px 6px 0;
   border: 1px solid transparent;
   border-radius: 2px;
   color: hsla(0,0%,100%,.8);
   font-size: 12px;
   line-height: 14px;
   -moz-user-select: none;
+       user-select: none;
   /* Opera does not support user-select, use <... unselectable="on"> instead */
   cursor: default;
   transition-property: background-color, border-color, box-shadow;
   transition-duration: 150ms;
   transition-timing-function: ease;
 }
 
 html[dir='ltr'] .toolbarButton,
@@ -1359,16 +1362,17 @@ html[dir='rtl'] .verticalToolbarSeparato
   margin: 4px 2px 4px 0;
   border: 1px solid transparent;
   border-radius: 2px;
   color: hsl(0,0%,85%);
   font-size: 12px;
   line-height: 14px;
   text-align: left;
   -moz-user-select: none;
+       user-select: none;
   cursor: default;
 }
 
 #thumbnailView {
   position: absolute;
   width: calc(100% - 60px);
   top: 0;
   bottom: 0;
@@ -1447,16 +1451,17 @@ a:focus > .thumbnail > .thumbnailSelecti
 #outlineView,
 #attachmentsView {
   position: absolute;
   width: calc(100% - 8px);
   top: 0;
   bottom: 0;
   overflow: auto;
   -moz-user-select: none;
+       user-select: none;
 }
 
 #outlineView {
   padding: 4px 4px 0;
 }
 #attachmentsView {
   padding: 3px 4px 0;
 }
@@ -1480,16 +1485,17 @@ html[dir='rtl'] .outlineItem > .outlineI
                                   of the container. */
   height: auto;
   margin-bottom: 1px;
   border-radius: 2px;
   color: hsla(0,0%,100%,.8);
   font-size: 13px;
   line-height: 15px;
   -moz-user-select: none;
+       user-select: none;
   white-space: normal;
 }
 
 .attachmentsItem > button {
   border: 0 none;
   background: none;
   cursor: pointer;
   width: 100%;
@@ -1574,18 +1580,18 @@ html[dir='rtl'] .outlineItemToggler::bef
   color: hsla(0,0%,100%,.8);
   font-style: italic;
   cursor: default;
 }
 
 /* TODO: file FF bug to support ::-moz-selection:window-inactive
    so we can override the opaque grey background when the window is inactive;
    see https://bugzilla.mozilla.org/show_bug.cgi?id=706209 */
+::-moz-selection { background: rgba(0,0,255,0.3); }
 ::selection { background: rgba(0,0,255,0.3); }
-::-moz-selection { background: rgba(0,0,255,0.3); }
 
 #errorWrapper {
   background: none repeat scroll 0 0 #FF5555;
   color: white;
   left: 0;
   position: absolute;
   right: 0;
   z-index: 1000;

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -6421,60 +6421,43 @@ nsContentUtils::GetUTFOrigin(nsIPrincipa
 }
 
 /* static */
 nsresult
 nsContentUtils::GetUTFOrigin(nsIURI* aURI, nsAString& aOrigin)
 {
   NS_PRECONDITION(aURI, "missing uri");
 
-  // For Blob URI we have to return the origin of page using its principal.
-  nsCOMPtr<nsIURIWithPrincipal> uriWithPrincipal = do_QueryInterface(aURI);
-  if (uriWithPrincipal) {
-    nsCOMPtr<nsIPrincipal> principal;
-    uriWithPrincipal->GetPrincipal(getter_AddRefs(principal));
-
-    if (principal) {
-      nsCOMPtr<nsIURI> uri;
-      nsresult rv = principal->GetURI(getter_AddRefs(uri));
-      NS_ENSURE_SUCCESS(rv, rv);
-
-      if (uri && uri != aURI) {
-        return GetUTFOrigin(uri, aOrigin);
-      }
-    } else {
-      // We are probably dealing with an unknown blob URL.
-      bool isBlobURL = false;
-      nsresult rv = aURI->SchemeIs(BLOBURI_SCHEME, &isBlobURL);
-      NS_ENSURE_SUCCESS(rv, rv);
-
-      if (isBlobURL) {
-        nsAutoCString path;
-        rv = aURI->GetPathQueryRef(path);
-        NS_ENSURE_SUCCESS(rv, rv);
-
-        nsCOMPtr<nsIURI> uri;
-        nsresult rv = NS_NewURI(getter_AddRefs(uri), path);
-        if (NS_FAILED(rv)) {
-          aOrigin.AssignLiteral("null");
-          return NS_OK;
-        }
-
-        return GetUTFOrigin(uri, aOrigin);
-      }
-    }
+  bool isBlobURL = false;
+  nsresult rv = aURI->SchemeIs(BLOBURI_SCHEME, &isBlobURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // For Blob URI, the path is the URL of the owning page.
+  if (isBlobURL) {
+    nsAutoCString path;
+    rv = aURI->GetPathQueryRef(path);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIURI> uri;
+    nsresult rv = NS_NewURI(getter_AddRefs(uri), path);
+    if (NS_FAILED(rv)) {
+      aOrigin.AssignLiteral("null");
+      return NS_OK;
+    }
+
+    return GetUTFOrigin(uri, aOrigin);
   }
 
   aOrigin.Truncate();
 
   nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
   NS_ENSURE_TRUE(uri, NS_ERROR_UNEXPECTED);
 
   nsCString host;
-  nsresult rv = uri->GetHost(host);
+  rv = uri->GetHost(host);
 
   if (NS_SUCCEEDED(rv) && !host.IsEmpty()) {
     nsCString scheme;
     rv = uri->GetScheme(scheme);
     NS_ENSURE_SUCCESS(rv, rv);
 
     int32_t port = -1;
     uri->GetPort(&port);

--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -5374,24 +5374,27 @@ def getJSToNativeConversionInfo(type, de
             getPromiseGlobal = dedent(
                 """
                 // We basically want our entry global here.  Play it safe
                 // and use GetEntryGlobal() to get it, with whatever
                 // principal-clamping it ends up doing.
                 globalObj = GetEntryGlobal()->GetGlobalJSObject();
                 """)
         else:
-            getPromiseGlobal = ""
+            getPromiseGlobal = dedent(
+                """
+                globalObj = JS::CurrentGlobalOrNull(cx);
+                """)
 
         templateBody = fill(
             """
             { // Scope for our GlobalObject, FastErrorResult, JSAutoCompartment,
               // etc.
 
-              JS::Rooted<JSObject*> globalObj(cx, JS::CurrentGlobalOrNull(cx));
+              JS::Rooted<JSObject*> globalObj(cx);
               $*{getPromiseGlobal}
               JSAutoCompartment ac(cx, globalObj);
               GlobalObject promiseGlobal(cx, globalObj);
               if (promiseGlobal.Failed()) {
                 $*{exceptionCode}
               }
 
               JS::Rooted<JS::Value> valueToResolve(cx, $${val});

--- a/dom/broadcastchannel/BroadcastChannel.cpp
+++ b/dom/broadcastchannel/BroadcastChannel.cpp
@@ -120,58 +120,16 @@ public:
 
 private:
   RefPtr<ThreadSafeWorkerRef> mWorkerRef;
   nsACString& mOrigin;
   PrincipalInfo& mPrincipalInfo;
   ErrorResult& mRv;
 };
 
-class BCPostMessageRunnable final : public nsIRunnable,
-                                    public nsICancelableRunnable
-{
-public:
-  NS_DECL_ISUPPORTS
-
-  BCPostMessageRunnable(BroadcastChannelChild* aActor,
-                        BroadcastChannelMessage* aData)
-    : mActor(aActor)
-    , mData(aData)
-  {
-    MOZ_ASSERT(mActor);
-  }
-
-  NS_IMETHOD Run() override
-  {
-    MOZ_ASSERT(mActor);
-    if (mActor->IsActorDestroyed()) {
-      return NS_OK;
-    }
-
-    ClonedMessageData message;
-    mData->BuildClonedMessageDataForBackgroundChild(mActor->Manager(), message);
-    mActor->SendPostMessage(message);
-    return NS_OK;
-  }
-
-  nsresult Cancel() override
-  {
-    mActor = nullptr;
-    return NS_OK;
-  }
-
-private:
-  ~BCPostMessageRunnable() {}
-
-  RefPtr<BroadcastChannelChild> mActor;
-  RefPtr<BroadcastChannelMessage> mData;
-};
-
-NS_IMPL_ISUPPORTS(BCPostMessageRunnable, nsICancelableRunnable, nsIRunnable)
-
 class CloseRunnable final : public nsIRunnable,
                             public nsICancelableRunnable
 {
 public:
   NS_DECL_ISUPPORTS
 
   explicit CloseRunnable(BroadcastChannel* aBC)
     : mBC(aBC)
@@ -393,45 +351,28 @@ void
 BroadcastChannel::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
                               ErrorResult& aRv)
 {
   if (mState != StateActive) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
 
-  PostMessageInternal(aCx, aMessage, aRv);
-}
-
-void
-BroadcastChannel::PostMessageInternal(JSContext* aCx,
-                                      JS::Handle<JS::Value> aMessage,
-                                      ErrorResult& aRv)
-{
   RefPtr<BroadcastChannelMessage> data = new BroadcastChannelMessage();
 
   data->Write(aCx, aMessage, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
 
-  PostMessageData(data);
-}
-
-void
-BroadcastChannel::PostMessageData(BroadcastChannelMessage* aData)
-{
   RemoveDocFromBFCache();
 
-  RefPtr<BCPostMessageRunnable> runnable =
-    new BCPostMessageRunnable(mActor, aData);
-
-  if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
-    NS_WARNING("Failed to dispatch to the current thread!");
-  }
+  ClonedMessageData message;
+  data->BuildClonedMessageDataForBackgroundChild(mActor->Manager(), message);
+  mActor->SendPostMessage(message);
 }
 
 void
 BroadcastChannel::Close()
 {
   if (mState != StateActive) {
     return;
   }

--- a/dom/broadcastchannel/tests/test_event_listener_leaks.html
+++ b/dom/broadcastchannel/tests/test_event_listener_leaks.html
@@ -18,20 +18,20 @@
 // exercise the leak condition.
 let count = 0;
 async function useBroadcastChannel(contentWindow) {
   contentWindow.messageCount = 0;
 
   count += 1;
   const name = `test_event_listener_leaks-${count}`;
 
+  let bc = new contentWindow.BroadcastChannel(name);
   let outer = new BroadcastChannel(name);
   outer.postMessage('foo');
 
-  let bc = new contentWindow.BroadcastChannel(name);
   await new Promise(resolve => {
     bc.onmessage = e => {
       contentWindow.messageCount += 1;
       resolve();
     };
   });
 
   is(contentWindow.messageCount, 1, "message should be received");

--- a/dom/encoding/FallbackEncoding.cpp
+++ b/dom/encoding/FallbackEncoding.cpp
@@ -1,16 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #include "mozilla/dom/FallbackEncoding.h"
 
+#include "mozilla/ArrayUtils.h"
 #include "mozilla/Encoding.h"
 #include "mozilla/intl/LocaleService.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "nsIObserverService.h"
 #include "nsUConvPropertySearch.h"
 
 using mozilla::intl::LocaleService;

--- a/dom/fetch/Request.cpp
+++ b/dom/fetch/Request.cpp
@@ -204,51 +204,38 @@ GetRequestURLFromWorker(const GlobalObje
                         nsAString& aRequestURL, nsACString& aURLfragment,
                         ErrorResult& aRv)
 {
   RefPtr<URL> url = ParseURLFromWorker(aGlobal, aInput, aRv);
   if (aRv.Failed()) {
     return;
   }
   nsString username;
-  url->GetUsername(username, aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
+  url->GetUsername(username);
 
   nsString password;
-  url->GetPassword(password, aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
+  url->GetPassword(password);
+
   if (!username.IsEmpty() || !password.IsEmpty()) {
     aRv.ThrowTypeError<MSG_URL_HAS_CREDENTIALS>(aInput);
     return;
   }
+
   // Get the fragment from URL.
   nsAutoString fragment;
-  url->GetHash(fragment, aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
+  url->GetHash(fragment);
 
   // Note: URL::GetHash() includes the "#" and we want the fragment with out
   // the hash symbol.
   if (!fragment.IsEmpty()) {
     CopyUTF16toUTF8(Substring(fragment, 1), aURLfragment);
   }
 
-  url->SetHash(EmptyString(), aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-  url->Stringify(aRequestURL, aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
+  url->SetHash(EmptyString());
+  url->Stringify(aRequestURL);
 }
 
 class ReferrerSameOriginChecker final : public WorkerMainThreadRunnable
 {
 public:
   ReferrerSameOriginChecker(WorkerPrivate* aWorkerPrivate,
                             const nsAString& aReferrerURL,
                             nsresult& aResult)
@@ -394,21 +381,17 @@ Request::Constructor(const GlobalObject&
           }
         }
       } else {
         RefPtr<URL> url = ParseURLFromWorker(aGlobal, referrer, aRv);
         if (NS_WARN_IF(aRv.Failed())) {
           aRv.ThrowTypeError<MSG_INVALID_REFERRER_URL>(referrer);
           return nullptr;
         }
-        url->Stringify(referrerURL, aRv);
-        if (NS_WARN_IF(aRv.Failed())) {
-          aRv.ThrowTypeError<MSG_INVALID_REFERRER_URL>(referrer);
-          return nullptr;
-        }
+        url->Stringify(referrerURL);
         if (!referrerURL.EqualsLiteral(kFETCH_CLIENT_REFERRER_STR)) {
           WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
           nsresult rv = NS_OK;
           // ReferrerSameOriginChecker uses a sync loop to get the main thread
           // to perform the same-origin check.  Overall, on Workers this method
           // can create 3 sync loops (two for constructing URLs and one here) so
           // in the future we may want to optimize it all by off-loading all of
           // this work in a single sync loop.

--- a/dom/fetch/Response.cpp
+++ b/dom/fetch/Response.cpp
@@ -124,21 +124,17 @@ Response::Redirect(const GlobalObject& a
     worker->AssertIsOnWorkerThread();
 
     NS_ConvertUTF8toUTF16 baseURL(worker->GetLocationInfo().mHref);
     RefPtr<URL> url = URL::WorkerConstructor(aGlobal, aUrl, baseURL, aRv);
     if (aRv.Failed()) {
       return nullptr;
     }
 
-    url->Stringify(parsedURL, aRv);
-  }
-
-  if (aRv.Failed()) {
-    return nullptr;
+    url->Stringify(parsedURL);
   }
 
   if (aStatus != 301 && aStatus != 302 && aStatus != 303 && aStatus != 307 && aStatus != 308) {
     aRv.ThrowRangeError<MSG_INVALID_REDIRECT_STATUSCODE_ERROR>();
     return nullptr;
   }
 
   Optional<Nullable<fetch::ResponseBodyInit>> body;

--- a/dom/interfaces/payments/nsIPaymentActionRequest.idl
+++ b/dom/interfaces/payments/nsIPaymentActionRequest.idl
@@ -77,25 +77,31 @@ interface nsIPaymentCreateActionRequest 
   readonly attribute nsIPaymentDetails details;
 
   /*
    *  The Options information of the payment request.
    */
   readonly attribute nsIPaymentOptions options;
 
   /*
+   *  The selected shipping option of the payment request;
+   */
+  readonly attribute AString shippingOption;
+
+  /*
    *  Initialize function the this request.
    */
   void initRequest(in AString aRequestId,
                    in nsIPaymentActionCallback aCallback,
                    in uint64_t aTabId,
                    in nsIPrincipal aPrincipal,
                    in nsIArray aMethodData,
                    in nsIPaymentDetails aDetails,
-                   in nsIPaymentOptions aOptions);
+                   in nsIPaymentOptions aOptions,
+		   in AString aShippingOption);
 };
 
 [builtinclass, uuid(4429697d-1135-47de-a46e-5196d399ec55)]
 interface nsIPaymentCompleteActionRequest : nsIPaymentActionRequest
 {
   /*
    *  The complete status from merchant side.
    */
@@ -113,21 +119,27 @@ interface nsIPaymentCompleteActionReques
 interface nsIPaymentUpdateActionRequest : nsIPaymentActionRequest
 {
   /*
    *  The details information for updating the specified payment request.
    */
   readonly attribute nsIPaymentDetails details;
 
   /*
+   *  The selected shipping option information
+   */
+  readonly attribute AString shippingOption;
+
+  /*
    *  Initialize function for this request.
    */
   void initRequest(in AString aRequestId,
                    in nsIPaymentActionCallback aCallback,
-                   in nsIPaymentDetails aDetails);
+                   in nsIPaymentDetails aDetails,
+		   in AString aShippingOption);
 };
 
 %{C++
 #define NS_PAYMENT_ACTION_REQUEST_CID \
   { 0x7ddbe8be, 0xbeac, 0x4952, { 0x96, 0xf6, 0x61, 0x99, 0x81, 0xdf, 0xf7, 0xa6 } }
 #define NS_PAYMENT_ACTION_REQUEST_CONTRACT_ID \
   "@mozilla.org/dom/payments/payment-action-request;1"
 

--- a/dom/interfaces/payments/nsIPaymentRequest.idl
+++ b/dom/interfaces/payments/nsIPaymentRequest.idl
@@ -80,12 +80,14 @@ interface nsIPaymentRequest : nsISupport
 {
   readonly attribute uint64_t tabId;
   readonly attribute nsIPrincipal topLevelPrincipal;
   readonly attribute AString requestId;
   readonly attribute AString completeStatus;
   readonly attribute nsIArray paymentMethods;
   readonly attribute nsIPaymentDetails paymentDetails;
   readonly attribute nsIPaymentOptions paymentOptions;
+  readonly attribute AString shippingOption;
 
   [noscript] void setCompleteStatus(in AString aCompleteStatus);
-  void updatePaymentDetails(in nsIPaymentDetails aDetails);
+  void updatePaymentDetails(in nsIPaymentDetails aDetails,
+                            in AString aShippingOption);
 };

--- a/dom/payments/PaymentActionRequest.cpp
+++ b/dom/payments/PaymentActionRequest.cpp
@@ -73,32 +73,34 @@ PaymentCreateActionRequest::PaymentCreat
 
 NS_IMETHODIMP
 PaymentCreateActionRequest::InitRequest(const nsAString& aRequestId,
                                         nsIPaymentActionCallback* aCallback,
                                         const uint64_t aTabId,
                                         nsIPrincipal* aTopLevelPrincipal,
                                         nsIArray* aMethodData,
                                         nsIPaymentDetails* aDetails,
-                                        nsIPaymentOptions* aOptions)
+                                        nsIPaymentOptions* aOptions,
+					const nsAString& aShippingOption)
 {
   NS_ENSURE_ARG_POINTER(aCallback);
   NS_ENSURE_ARG_POINTER(aTopLevelPrincipal);
   NS_ENSURE_ARG_POINTER(aMethodData);
   NS_ENSURE_ARG_POINTER(aDetails);
   NS_ENSURE_ARG_POINTER(aOptions);
   nsresult rv = Init(aRequestId, nsIPaymentActionRequest::CREATE_ACTION, aCallback);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   mTabId = aTabId;
   mTopLevelPrincipal = aTopLevelPrincipal;
   mMethodData = aMethodData;
   mDetails = aDetails;
   mOptions = aOptions;
+  mShippingOption = aShippingOption;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PaymentCreateActionRequest::GetTabId(uint64_t* aTabId)
 {
   NS_ENSURE_ARG_POINTER(aTabId);
   *aTabId = mTabId;
@@ -140,16 +142,23 @@ PaymentCreateActionRequest::GetOptions(n
 {
   NS_ENSURE_ARG_POINTER(aOptions);
   MOZ_ASSERT(mOptions);
   nsCOMPtr<nsIPaymentOptions> options = mOptions;
   options.forget(aOptions);
   return NS_OK;
 }
 
+NS_IMETHODIMP
+PaymentCreateActionRequest::GetShippingOption(nsAString& aShippingOption)
+{
+  aShippingOption = mShippingOption;
+  return NS_OK;
+}
+
 /* PaymentCompleteActionRequest */
 
 NS_IMPL_ISUPPORTS_INHERITED(PaymentCompleteActionRequest,
                             PaymentActionRequest,
                             nsIPaymentCompleteActionRequest)
 
 PaymentCompleteActionRequest::PaymentCompleteActionRequest()
   : mCompleteStatus(EmptyString())
@@ -189,24 +198,33 @@ PaymentUpdateActionRequest::GetDetails(n
   NS_ENSURE_ARG_POINTER(aDetails);
   MOZ_ASSERT(mDetails);
   nsCOMPtr<nsIPaymentDetails> details = mDetails;
   details.forget(aDetails);
   return NS_OK;
 }
 
 NS_IMETHODIMP
+PaymentUpdateActionRequest::GetShippingOption(nsAString& aShippingOption)
+{
+  aShippingOption = mShippingOption;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 PaymentUpdateActionRequest::InitRequest(const nsAString& aRequestId,
                                         nsIPaymentActionCallback* aCallback,
-                                        nsIPaymentDetails* aDetails)
+                                        nsIPaymentDetails* aDetails,
+					const nsAString& aShippingOption)
 {
   NS_ENSURE_ARG_POINTER(aCallback);
   NS_ENSURE_ARG_POINTER(aDetails);
   nsresult rv = Init(aRequestId, nsIPaymentActionRequest::UPDATE_ACTION, aCallback);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   mDetails = aDetails;
+  mShippingOption = aShippingOption;
   return NS_OK;
 }
 
 } // end of namespace dom
 } // end of namespace mozilla

--- a/dom/payments/PaymentActionRequest.h
+++ b/dom/payments/PaymentActionRequest.h
@@ -44,16 +44,17 @@ public:
 private:
   ~PaymentCreateActionRequest() = default;
 
   uint64_t mTabId;
   nsCOMPtr<nsIPrincipal> mTopLevelPrincipal;
   nsCOMPtr<nsIArray> mMethodData;
   nsCOMPtr<nsIPaymentDetails> mDetails;
   nsCOMPtr<nsIPaymentOptions> mOptions;
+  nsString mShippingOption;
 };
 
 class PaymentCompleteActionRequest final : public nsIPaymentCompleteActionRequest
                                          , public PaymentActionRequest
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_FORWARD_NSIPAYMENTACTIONREQUEST(PaymentActionRequest::)
@@ -75,14 +76,15 @@ public:
   NS_FORWARD_NSIPAYMENTACTIONREQUEST(PaymentActionRequest::)
   NS_DECL_NSIPAYMENTUPDATEACTIONREQUEST
 
   PaymentUpdateActionRequest() = default;
 private:
   ~PaymentUpdateActionRequest() = default;
 
   nsCOMPtr<nsIPaymentDetails> mDetails;
+  nsString mShippingOption;
 };
 
 } // end of namespace dom
 } // end of namespace mozilla
 
 #endif

--- a/dom/payments/PaymentRequestData.cpp
+++ b/dom/payments/PaymentRequestData.cpp
@@ -604,23 +604,25 @@ PaymentOptions::GetShippingType(nsAStrin
 NS_IMPL_ISUPPORTS(PaymentRequest,
                   nsIPaymentRequest)
 
 PaymentRequest::PaymentRequest(const uint64_t aTabId,
                                const nsAString& aRequestId,
                                nsIPrincipal* aTopLevelPrincipal,
                                nsIArray* aPaymentMethods,
                                nsIPaymentDetails* aPaymentDetails,
-                               nsIPaymentOptions* aPaymentOptions)
+                               nsIPaymentOptions* aPaymentOptions,
+			       const nsAString& aShippingOption)
   : mTabId(aTabId)
   , mRequestId(aRequestId)
   , mTopLevelPrincipal(aTopLevelPrincipal)
   , mPaymentMethods(aPaymentMethods)
   , mPaymentDetails(aPaymentDetails)
   , mPaymentOptions(aPaymentOptions)
+  , mShippingOption(aShippingOption)
 {
 }
 
 NS_IMETHODIMP
 PaymentRequest::GetTabId(uint64_t* aTabId)
 {
   NS_ENSURE_ARG_POINTER(aTabId);
   *aTabId = mTabId;
@@ -670,24 +672,33 @@ PaymentRequest::GetPaymentOptions(nsIPay
   NS_ENSURE_ARG_POINTER(aPaymentOptions);
   MOZ_ASSERT(mPaymentOptions);
   nsCOMPtr<nsIPaymentOptions> options = mPaymentOptions;
   options.forget(aPaymentOptions);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-PaymentRequest::UpdatePaymentDetails(nsIPaymentDetails* aPaymentDetails)
+PaymentRequest::GetShippingOption(nsAString& aShippingOption)
+{
+  aShippingOption = mShippingOption;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::UpdatePaymentDetails(nsIPaymentDetails* aPaymentDetails,
+                                     const nsAString& aShippingOption)
 {
   MOZ_ASSERT(aPaymentDetails);
   bool requestShipping;
   nsresult rv = mPaymentOptions->GetRequestShipping(&requestShipping);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
+  mShippingOption = aShippingOption;
   return mPaymentDetails->Update(aPaymentDetails, requestShipping);
 }
 
 NS_IMETHODIMP
 PaymentRequest::SetCompleteStatus(const nsAString& aCompleteStatus)
 {
   mCompleteStatus = aCompleteStatus;
   return NS_OK;

--- a/dom/payments/PaymentRequestData.h
+++ b/dom/payments/PaymentRequestData.h
@@ -179,28 +179,30 @@ public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIPAYMENTREQUEST
 
   PaymentRequest(const uint64_t aTabId,
                  const nsAString& aRequestId,
                  nsIPrincipal* aPrincipal,
                  nsIArray* aPaymentMethods,
                  nsIPaymentDetails* aPaymentDetails,
-                 nsIPaymentOptions* aPaymentOptions);
+                 nsIPaymentOptions* aPaymentOptions,
+		 const nsAString& aShippingOption);
 
 private:
   ~PaymentRequest() = default;
 
   uint64_t mTabId;
   nsString mRequestId;
   nsString mCompleteStatus;
   nsCOMPtr<nsIPrincipal> mTopLevelPrincipal;
   nsCOMPtr<nsIArray> mPaymentMethods;
   nsCOMPtr<nsIPaymentDetails> mPaymentDetails;
   nsCOMPtr<nsIPaymentOptions> mPaymentOptions;
+  nsString mShippingOption;
 };
 
 class PaymentAddress final : public nsIPaymentAddress
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIPAYMENTADDRESS
 

--- a/dom/payments/PaymentRequestManager.cpp
+++ b/dom/payments/PaymentRequestManager.cpp
@@ -462,17 +462,18 @@ PaymentRequestManager::CreatePayment(JSC
 
   IPCPaymentOptions options;
   ConvertOptions(aOptions, options);
 
   IPCPaymentCreateActionRequest action(internalId,
                                        IPC::Principal(aTopLevelPrincipal),
                                        methodData,
                                        details,
-                                       options);
+                                       options,
+				       shippingOption);
 
   rv = SendRequestPayment(request, action, true);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   mRequestQueue.AppendElement(request);
   request.forget(aRequest);
   return NS_OK;
@@ -568,17 +569,17 @@ PaymentRequestManager::UpdatePayment(JSC
   nsAutoString shippingOption;
   SetDOMStringToNull(shippingOption);
   if (aRequestShipping) {
     GetSelectedShippingOption(aDetails, shippingOption);
     request->SetShippingOption(shippingOption);
   }
 
   nsAutoString requestId(aRequestId);
-  IPCPaymentUpdateActionRequest action(requestId, details);
+  IPCPaymentUpdateActionRequest action(requestId, details, shippingOption);
   return SendRequestPayment(request, action);
 }
 
 nsresult
 PaymentRequestManager::RespondPayment(const IPCPaymentActionResponse& aResponse)
 {
   switch (aResponse.type()) {
     case IPCPaymentActionResponse::TIPCPaymentCanMakeActionResponse: {

--- a/dom/payments/PaymentRequestService.cpp
+++ b/dom/payments/PaymentRequestService.cpp
@@ -248,19 +248,23 @@ PaymentRequestService::RequestPayment(ns
       nsCOMPtr<nsIPaymentDetails> details;
       rv = request->GetDetails(getter_AddRefs(details));
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsCOMPtr<nsIPaymentOptions> options;
       rv = request->GetOptions(getter_AddRefs(options));
       NS_ENSURE_SUCCESS(rv, rv);
 
+      nsAutoString shippingOption;
+      rv = request->GetShippingOption(shippingOption);
+      NS_ENSURE_SUCCESS(rv, rv);
+
       nsCOMPtr<nsIPaymentRequest> payment =
         new payments::PaymentRequest(tabId, requestId, topLevelPrincipal,
-                                     methodData, details, options);
+                                     methodData, details, options, shippingOption);
 
       if (!mRequestQueue.AppendElement(payment, mozilla::fallible)) {
         return NS_ERROR_OUT_OF_MEMORY;
       }
       break;
     }
     case nsIPaymentActionRequest::CANMAKE_ACTION: {
       nsCOMPtr<nsIPaymentCanMakeActionResponse> canMakeResponse =
@@ -352,24 +356,28 @@ PaymentRequestService::RequestPayment(ns
     case nsIPaymentActionRequest::UPDATE_ACTION: {
       nsCOMPtr<nsIPaymentUpdateActionRequest> request = do_QueryInterface(aRequest);
       MOZ_ASSERT(request);
 
       nsCOMPtr<nsIPaymentDetails> details;
       rv = request->GetDetails(getter_AddRefs(details));
       NS_ENSURE_SUCCESS(rv, rv);
 
+      nsAutoString shippingOption;
+      rv = request->GetShippingOption(shippingOption);
+      NS_ENSURE_SUCCESS(rv, rv);
+
       rv = request->GetRequestId(requestId);
       NS_ENSURE_SUCCESS(rv, rv);
       nsCOMPtr<nsIPaymentRequest> payment;
       rv = GetPaymentRequestById(requestId, getter_AddRefs(payment));
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
-      rv = payment->UpdatePaymentDetails(details);
+      rv = payment->UpdatePaymentDetails(details, shippingOption);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
       if (mShowingRequest) {
         MOZ_ASSERT(mShowingRequest == payment);
         rv = LaunchUIAction(requestId, type);
       } else {
         mShowingRequest = payment;

--- a/dom/payments/ipc/PPaymentRequest.ipdl
+++ b/dom/payments/ipc/PPaymentRequest.ipdl
@@ -71,16 +71,17 @@ struct IPCPaymentOptions
 
 struct IPCPaymentCreateActionRequest
 {
   nsString requestId;
   Principal topLevelPrincipal;
   IPCPaymentMethodData[] methodData;
   IPCPaymentDetails details;
   IPCPaymentOptions options;
+  nsString shippingOption;
 };
 
 struct IPCPaymentCanMakeActionRequest
 {
   nsString requestId;
 };
 
 struct IPCPaymentShowActionRequest
@@ -98,16 +99,17 @@ struct IPCPaymentCompleteActionRequest
   nsString requestId;
   nsString completeStatus;
 };
 
 struct IPCPaymentUpdateActionRequest
 {
   nsString requestId;
   IPCPaymentDetails details;
+  nsString shippingOption;
 };
 
 union IPCPaymentActionRequest
 {
   IPCPaymentCreateActionRequest;
   IPCPaymentCanMakeActionRequest;
   IPCPaymentShowActionRequest;
   IPCPaymentAbortActionRequest;

--- a/dom/payments/ipc/PaymentRequestParent.cpp
+++ b/dom/payments/ipc/PaymentRequestParent.cpp
@@ -71,17 +71,18 @@ PaymentRequestParent::RecvRequestPayment
         return IPC_FAIL_NO_REASON(this);
       }
       rv = createAction->InitRequest(request.requestId(),
                                      callback,
                                      mTabId,
                                      request.topLevelPrincipal(),
                                      methodData,
                                      details,
-                                     options);
+                                     options,
+				     request.shippingOption());
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return IPC_FAIL_NO_REASON(this);
       }
 
       action = do_QueryInterface(createAction);
       MOZ_ASSERT(action);
       break;
     }
@@ -137,17 +138,18 @@ PaymentRequestParent::RecvRequestPayment
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return IPC_FAIL_NO_REASON(this);
       }
 
       nsCOMPtr<nsIPaymentUpdateActionRequest> updateAction =
         do_CreateInstance(NS_PAYMENT_UPDATE_ACTION_REQUEST_CONTRACT_ID);
       rv = updateAction->InitRequest(request.requestId(),
                                      callback,
-                                     details);
+                                     details,
+				     request.shippingOption());
       action = do_QueryInterface(updateAction);
       MOZ_ASSERT(action);
       break;
     }
     default: {
       return IPC_FAIL(this, "Unexpected request type");
     }
   }

new file mode 100644
--- /dev/null
+++ b/dom/payments/test/DefaultData.js
@@ -0,0 +1,50 @@
+// testing data declation
+const defaultMethods = [{
+  supportedMethods: "basic-card",
+  data: {
+    supportedNetworks: ['unionpay', 'visa', 'mastercard', 'amex', 'discover',
+                        'diners', 'jcb', 'mir',
+    ],
+    supportedTypes: ['prepaid', 'debit', 'credit'],
+  },
+}, {
+  supportedMethods: "testing-payment-method",
+}];
+
+const defaultDetails = {
+  total: {
+    label: "Total",
+    amount: {
+      currency: "USD",
+      value: "1.00",
+    }
+  },
+  shippingOptions: [
+    {
+      id: "NormalShipping",
+      label: "NormalShipping",
+      amount: {
+        currency: "USD",
+        value: "10.00",
+      },
+      selected: false,
+    },
+    {
+      id: "FastShipping",
+      label: "FastShipping",
+      amount: {
+        currency: "USD",
+        value: "5.00",
+      },
+      selected: false,
+    },
+  ],
+};
+
+const defaultOptions = {
+  requestPayerName: true,
+  requestPayerEmail: false,
+  reqeustPayerPhone: false,
+  requestShipping: true,
+  shippingType: "shipping"
+};

rename from dom/payments/test/Bug1443914ChromeScript.js
rename to dom/payments/test/ShippingOptionsChromeScript.js
--- a/dom/payments/test/Bug1443914ChromeScript.js
+++ b/dom/payments/test/ShippingOptionsChromeScript.js
@@ -9,72 +9,84 @@ const paymentSrv = Cc["@mozilla.org/dom/
 
 function emitTestFail(message) {
   sendAsyncMessage("test-fail", message);
 }
 function emitTestPass(message) {
   sendAsyncMessage("test-pass", message);
 }
 
-const shippingAddress = Cc["@mozilla.org/dom/payments/payment-address;1"].
-                           createInstance(Ci.nsIPaymentAddress);
-const addressLine = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
-const address = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
-address.data = "Easton Ave";
-addressLine.appendElement(address);
-shippingAddress.init("USA",              // country
-                     addressLine,        // address line
-                     "CA",               // region
-                     "San Bruno",        // city
-                     "Test locality",    // dependent locality
-                     "94066",            // postal code
-                     "123456",           // sorting code
-                     "en",               // language code
-                     "Testing Org",      // organization
-                     "Bill A. Pacheco",  // recipient
-                     "+1-434-441-3879"); // phone
+let expectedRequestOption = null;
+let expectedUpdatedOption = null;
+let changeShippingOption = null;
+
+function showResponse(requestId) {
+  const showResponseData = Cc["@mozilla.org/dom/payments/general-response-data;1"].
+                              createInstance(Ci.nsIGeneralResponseData);
+  showResponseData.initData({});
+  const showResponse = Cc["@mozilla.org/dom/payments/payment-show-action-response;1"].
+                          createInstance(Ci.nsIPaymentShowActionResponse);
+  showResponse.init(requestId,
+                    Ci.nsIPaymentActionResponse.PAYMENT_ACCEPTED,
+                    "testing-payment-method",   // payment method
+                    showResponseData,           // payment method data
+                    "Bill A. Pacheco",          // payer name
+                    "",                         // payer email
+                    "");                        // payer phone
+  paymentSrv.respondPayment(showResponse.QueryInterface(Ci.nsIPaymentActionResponse));
+}
+
+function showRequest(requestId) {
+  let request = paymentSrv.getPaymentRequestById(requestId);
+  const message = "request.shippingOption should be " + expectedRequestOption +
+                  " when calling show(), but got " + request.shippingOption + ".";
+  if (request.shippingOption != expectedRequestOption) {
+    emitTestFail(message);
+  } else {
+    emitTestPass(message);
+  }
+  if (changeShippingOption) {
+    paymentSrv.changeShippingOption(requestId, changeShippingOption);
+  } else {
+    showResponse(requestId);
+  }
+}
+
+function updateRequest(requestId) {
+  let request = paymentSrv.getPaymentRequestById(requestId);
+  const message = "request.shippingOption should be " + expectedUpdatedOption +
+                  " when calling updateWith(), but got " + request.shippingOption + ".";
+  if (request.shippingOption != expectedUpdatedOption) {
+    emitTestFail(message);
+  } else {
+    emitTestPass(message);
+  }
+  showResponse(requestId);
+}
 
 const TestingUIService = {
-  showPayment: function(requestId) {
-    paymentSrv.changeShippingAddress(requestId, shippingAddress);
-  },
+  showPayment: showRequest,
   abortPayment: function(requestId) {
   },
   completePayment: function(requestId) {
     let request = paymentSrv.getPaymentRequestById(requestId);
     let completeResponse = Cc["@mozilla.org/dom/payments/payment-complete-action-response;1"].
                            createInstance(Ci.nsIPaymentCompleteActionResponse);
     completeResponse.init(requestId, Ci.nsIPaymentActionResponse.COMPLETE_SUCCEEDED);
     paymentSrv.respondPayment(completeResponse.QueryInterface(Ci.nsIPaymentActionResponse));
   },
-  updatePayment: function(requestId) {
-    let request = paymentSrv.getPaymentRequestById(requestId);
-    if (request.shippingOptions != null) {
-      emitTestFail("request.shippingOptions should be null");
-    } else {
-      emitTestPass("request.shippingOptions should be null");
-    }
-    const showResponseData = Cc["@mozilla.org/dom/payments/general-response-data;1"].
-                                createInstance(Ci.nsIGeneralResponseData);
-    showResponseData.initData({});
-    const showResponse = Cc["@mozilla.org/dom/payments/payment-show-action-response;1"].
-                            createInstance(Ci.nsIPaymentShowActionResponse);
-    showResponse.init(requestId,
-                      Ci.nsIPaymentActionResponse.PAYMENT_ACCEPTED,
-                      "testing-payment-method",   // payment method
-                      showResponseData,           // payment method data
-                      "Bill A. Pacheco",          // payer name
-                      "",                         // payer email
-                      "");                        // payer phone
-    paymentSrv.respondPayment(showResponse.QueryInterface(Ci.nsIPaymentActionResponse));
-  },
+  updatePayment: updateRequest,
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIPaymentUIService]),
 };
 
-addMessageListener("set-checking-shipping-options-ui-service", function() {
-  paymentSrv.setTestingUIService(TestingUIService.QueryInterface(Ci.nsIPaymentUIService));
+paymentSrv.setTestingUIService(TestingUIService.QueryInterface(Ci.nsIPaymentUIService));
+
+addMessageListener("set-expected-results", function(results) {
+  expectedRequestOption = results.requestResult;
+  expectedUpdatedOption = results.responseResult;
+  changeShippingOption = results.changeOptionResult;
 });
 
 addMessageListener("teardown", function() {
   paymentSrv.cleanup();
   paymentSrv.setTestingUIService(null);
   sendAsyncMessage('teardown-complete');
 });

--- a/dom/payments/test/mochitest.ini
+++ b/dom/payments/test/mochitest.ini
@@ -1,30 +1,31 @@
 [DEFAULT]
 # skip-if !e10s will be removed once non-e10s is supported
 skip-if = !e10s
 scheme = https
 support-files =
   simple_payment_request.html
   echo_payment_request.html
   BasiccardChromeScript.js
-  Bug1443914ChromeScript.js
   ConstructorChromeScript.js
   CurrencyAmountValidationChromeScript.js
+  DefaultData.js
   GeneralChromeScript.js
   PMIValidationChromeScript.js
+  ShippingOptionsChromeScript.js
   ShowPaymentChromeScript.js
   RequestShippingChromeScript.js
 
 [test_abortPayment.html]
 run-if = nightly_build # Bug 1390018: Depends on the Nightly-only UI service
 [test_basiccard.html]
 [test_block_none10s.html]
 skip-if = e10s # Bug 1408250: Don't expose PaymentRequest Constructor in non-e10s
-[test_bug1443914.html]
 [test_canMakePayment.html]
 run-if = nightly_build # Bug 1390737: Depends on the Nightly-only UI service
 [test_constructor.html]
 [test_currency_amount_validation.html]
 [test_payment-request-in-iframe.html]
 [test_pmi_validation.html]
 [test_requestShipping.html]
+[test_shippingOptions.html]
 [test_showPayment.html]

rename from dom/payments/test/test_bug1443914.html
rename to dom/payments/test/test_shippingOptions.html
--- a/dom/payments/test/test_bug1443914.html
+++ b/dom/payments/test/test_shippingOptions.html
@@ -1,127 +1,194 @@
 <!DOCTYPE HTML>
 <html>
 <!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1440041
 https://bugzilla.mozilla.org/show_bug.cgi?id=1443914
 -->
 <head>
   <meta charset="utf-8">
-  <title>Test for Bug 1443914</title>
+  <title>Test for shippingOptions related bugs</title>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
   <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="./DefaultData.js"></script>
   <script type="application/javascript">
 
   "use strict";
   SimpleTest.waitForExplicitFinish();
 
-  var gUrl = SimpleTest.getTestFileURL('Bug1443914ChromeScript.js');
+  var gUrl = SimpleTest.getTestFileURL('ShippingOptionsChromeScript.js');
   var gScript = SpecialPowers.loadChromeScript(gUrl);
 
   function testFailHandler(message) {
     ok(false, message);
   }
   function testPassHandler(message) {
     ok(true, message);
   }
   gScript.addMessageListener("test-fail", testFailHandler);
   gScript.addMessageListener("test-pass", testPassHandler);
 
-  // testing data declation
-  const defaultMethods = [{
-    supportedMethods: "basic-card",
-    data: {
-      supportedNetworks: ['unionpay', 'visa', 'mastercard', 'amex', 'discover',
-                          'diners', 'jcb', 'mir',
-      ],
-      supportedTypes: ['prepaid', 'debit', 'credit'],
+  let shippingOptions = [{
+    id: "NormalShipping",
+    label: "NormalShipping",
+    amount: {
+      currency: "USD",
+      value: "10.00",
     },
-  }, {
-    supportedMethods: "testing-payment-method",
-  }];
-
-  const defaultDetails = {
-    id: "test payment",
-    total: {
-      label: "Total",
-      amount: {
-        currency: "USD",
-        value: "1.00"
-      }
+    selected: true,
+  },{
+    id: "FastShipping",
+    label: "FastShipping",
+    amount: {
+      currency: "USD",
+      value: "5.00",
     },
-    shippingOptions: [
-      {
-        id: "NormalShipping",
-        label: "NormalShipping",
-        amount: {
-          currency: "USD",
-          value: "10.00"
-        },
-        selected: false,
-      },
-    ],
-  };
-
-  const defaultOptions = {
-    requestPayerName: true,
-    requestPayerEmail: false,
-    reqeustPayerPhone: false,
-    requestShipping: true,
-    shippingType: "shipping"
-  };
+    selected: false,
+  }]
 
-  const updateDetails = {
-    total: {
-      label: "Total",
-      amount: {
-        currency: "USD",
-        value: "1.00"
+  // testing function main body
+  function testShippingOptionsTemplate(initDetails,
+				       optionUpdateDetails,
+                                       expectedRequestOption,
+				       expectedOptionChangeOption,
+				       expectedResponseOption) {
+    const expectedResults = {requestResult: expectedRequestOption,
+                             changeOptionResult: expectedOptionChangeOption,
+                             responseResult: expectedResponseOption,};
+    gScript.sendAsyncMessage("set-expected-results", expectedResults);
+    return new Promise((resolve, reject) => {
+      const request = new PaymentRequest(defaultMethods, initDetails, defaultOptions);
+      const handler = SpecialPowers.getDOMWindowUtils(window).setHandlingUserInput(true);
+      is(request.shippingOption, expectedRequestOption,
+         "request.shippingOption should be " + expectedRequestOption +
+	 " after created, but got " + request.shippingOption + ".");
+      if (optionUpdateDetails) {
+	request.addEventListener("shippingoptionchange", event => {
+	  is(request.shippingOption, expectedOptionChangeOption,
+             "request.shippingOption should be " + expectedOptionChangeOption +
+	     " in shippingoptionchange event, but got " + request.shippingOption + ".");
+          event.updateWith(optionUpdateDetails);
+	});
       }
-    },
-    error: "",
-  };
-  // testing function main body
-  function test_bug1443914() {
-    gScript.sendAsyncMessage("set-checking-shipping-options-ui-service");
-    return new Promise((resolve, reject) => {
-      const request = new PaymentRequest(defaultMethods, defaultDetails, defaultOptions);
-      const handler = SpecialPowers.getDOMWindowUtils(window).setHandlingUserInput(true);
-      request.addEventListener("shippingaddresschange", (event) => {
-        event.updateWith(updateDetails);
-      });
-      request.addEventListener("shippingoptionchange", (event) => {
-        event.updateWith(updateDetails);
-      });
       request.show().then(response => {
-        response.complete("success").then(() => {
+        is(response.shippingOption, expectedResponseOption,
+	"response.shippingOption should be " + expectedResponseOption +
+	 ", but got " + response.shippingOption + ".");
+	response.complete("success").then(() => {
 	  resolve();
 	}).catch(error => {
 	  ok(false, "Unexpected error: " + error.name);
 	  resolve();
-	});
+	})
+      }, response => {
       }).catch(error => {
         ok(false, "Unexpected error: " + error.name);
 	resolve();
       }).finally(handler.destruct);
     });
   }
 
+  // test no selected shipping option in default
+  function testNoSelectedShippingOptions() {
+    return testShippingOptionsTemplate(defaultDetails,   // initial details
+				       null,             // update details for optionchange
+				       null,             // expected request.shippintOption after create
+				       null,             // expected request.shippingOption after optionchange
+				       null);            // expected response.shippingOption
+  }
+
+  // test select one shipping option in default
+  function testSelectedOneShippingOption() {
+    let details = Object.assign({}, defaultDetails);
+    details.shippingOptions = shippingOptions;
+    details.shippingOptions[0].selected = true;
+    details.shippingOptions[1].selected = false;
+    const expectedOption = details.shippingOptions[0].id;
+    return testShippingOptionsTemplate(details,          // initial details
+				       null,             // update details for optionchange
+				       expectedOption,   // expected request.shippintOption after create
+				       null,             // expected request.shippingOption after optionchange
+				       expectedOption);  // expected response.shippingOption
+  }
+
+  // test select multiple shipping options in default
+  function testMultiSelectedShippingOptions() {
+    let details = Object.assign({}, defaultDetails);
+    details.shippingOptions = shippingOptions;
+    details.shippingOptions[0].selected = true;
+    details.shippingOptions[1].selected = true;
+    const expectedOption = details.shippingOptions[1].id;
+    return testShippingOptionsTemplate(details,          // initial details
+				       null,             // update details for optionchange
+				       expectedOption,   // expected request.shippintOption after create
+				       null,             // expected request.shippingOption after optionchange
+				       expectedOption);  // expected response.shippingOption
+  }
+
+  // test no selected shipping option in default, but selected by user
+  function testSelectedByUser() {
+    let updateDetails = Object.assign({}, defaultDetails);
+    updateDetails.shippingOptions = shippingOptions;
+    updateDetails.shippingOptions[0].selected = true;
+    updateDetails.shippingOptions[1].selected = false;
+    const expectedOption = updateDetails.shippingOptions[0].id;
+    return testShippingOptionsTemplate(defaultDetails,   // initial details
+				       updateDetails,    // update details for optionchange
+				       null,             // expected request.shippintOption after create
+				       expectedOption,   // expected request.shippingOption after optionchange
+				       expectedOption);  // expected response.shippingOption
+  }
+
+  // test no selected shipping option in default, but selected by user then updated
+  // by merchant to the other.
+  function testUpdateSelectedByMerchant() {
+    let updateDetails = Object.assign({}, defaultDetails);
+    updateDetails.shippingOptions = shippingOptions;
+    updateDetails.shippingOptions[0].selected = false;
+    updateDetails.shippingOptions[1].selected = true;
+    const expectedOption = updateDetails.shippingOptions[0].id;
+    const expectedResponse = updateDetails.shippingOptions[1].id;
+    return testShippingOptionsTemplate(defaultDetails,   // initial details
+				       updateDetails,    // update details for optionchange
+				       null,             // expected request.shippintOption after create
+				       expectedOption,   // expected request.shippingOption after optionchange
+				       expectedResponse);// expected response.shippingOption
+  }
+
+  // test update shipping options to null
+  function testUpdateShippingOptionsToNull() {
+    let updateDetails = Object.assign({}, defaultDetails);
+    delete updateDetails.shippingOptions;
+    const expectedOption = defaultDetails.shippingOptions[0].id;
+    return testShippingOptionsTemplate(defaultDetails,   // initial details
+				       updateDetails,    // update details for optionchange
+				       null,             // expected request.shippintOption after create
+				       expectedOption,   // expected request.shippingOption after optionchange
+				       null);            // expected response.shippingOption
+  }
+
   function teardown() {
     gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
       gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
       gScript.removeMessageListener("test-fail", testFailHandler);
       gScript.removeMessageListener("test-pass", testPassHandler);
       gScript.destroy();
       SimpleTest.finish();
     });
     gScript.sendAsyncMessage("teardown");
   }
 
   function runTests() {
-    test_bug1443914()
+    testNoSelectedShippingOptions()
+    .then(testSelectedOneShippingOption)
+    .then(testMultiSelectedShippingOptions)
+    .then(testSelectedByUser)
+    .then(testUpdateSelectedByMerchant)
+    .then(testUpdateShippingOptionsToNull)
     .then(teardown)
     .catch( e => {
       ok(false, "Unexpected error: " + e.name);
       SimpleTest.finish();
     });
   }
 
   window.addEventListener('load', function() {
@@ -130,11 +197,12 @@ https://bugzilla.mozilla.org/show_bug.cg
         ['dom.payments.request.enabled', true],
       ]
     }, runTests);
   });
 
   </script>
 </head>
 <body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1440041">Mozilla Bug 1440041</a>
 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1443914">Mozilla Bug 1443914</a>
 </body>
 </html>

--- a/dom/url/URL.cpp
+++ b/dom/url/URL.cpp
@@ -121,31 +121,28 @@ URL::CreateSearchParamsIfNeeded()
 {
   if (!mSearchParams) {
     mSearchParams = new URLSearchParams(mParent, this);
     UpdateURLSearchParams();
   }
 }
 
 void
-URL::SetSearch(const nsAString& aSearch, ErrorResult& aRv)
+URL::SetSearch(const nsAString& aSearch)
 {
-  SetSearchInternal(aSearch, aRv);
+  SetSearchInternal(aSearch);
   UpdateURLSearchParams();
 }
 
 void
 URL::URLSearchParamsUpdated(URLSearchParams* aSearchParams)
 {
   MOZ_ASSERT(mSearchParams);
   MOZ_ASSERT(mSearchParams == aSearchParams);
 
   nsAutoString search;
   mSearchParams->Serialize(search);
 
-  ErrorResult rv;
-  SetSearchInternal(search, rv);
-  NS_WARNING_ASSERTION(!rv.Failed(), "SetSearchInternal failed");
-  rv.SuppressException();
+  SetSearchInternal(search);
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/url/URL.h
+++ b/dom/url/URL.h
@@ -73,104 +73,104 @@ public:
   RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aURL,
                   ErrorResult& aRv);
 
   static bool
   IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
              ErrorResult& aRv);
 
   virtual void
-  GetHref(nsAString& aHref, ErrorResult& aRv) const = 0;
+  GetHref(nsAString& aHref) const = 0;
 
   virtual void
   SetHref(const nsAString& aHref, ErrorResult& aRv) = 0;
 
   virtual void
   GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const = 0;
 
   virtual void
-  GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const = 0;
+  GetProtocol(nsAString& aProtocol) const = 0;
 
   virtual void
   SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) = 0;
 
   virtual void
-  GetUsername(nsAString& aUsername, ErrorResult& aRv) const = 0;
+  GetUsername(nsAString& aUsername) const = 0;
 
   virtual void
-  SetUsername(const nsAString& aUsername, ErrorResult& aRv) = 0;
+  SetUsername(const nsAString& aUsername) = 0;
 
   virtual void
-  GetPassword(nsAString& aPassword, ErrorResult& aRv) const = 0;
+  GetPassword(nsAString& aPassword) const = 0;
 
   virtual void
-  SetPassword(const nsAString& aPassword, ErrorResult& aRv) = 0;
+  SetPassword(const nsAString& aPassword) = 0;
 
   virtual void
-  GetHost(nsAString& aHost, ErrorResult& aRv) const = 0;
+  GetHost(nsAString& aHost) const = 0;
 
   virtual void
-  SetHost(const nsAString& aHost, ErrorResult& aRv) = 0;
+  SetHost(const nsAString& aHost) = 0;
 
   virtual void
-  GetHostname(nsAString& aHostname, ErrorResult& aRv) const = 0;
+  GetHostname(nsAString& aHostname) const = 0;
 
   virtual void
-  SetHostname(const nsAString& aHostname, ErrorResult& aRv) = 0;
+  SetHostname(const nsAString& aHostname) = 0;
 
   virtual void
-  GetPort(nsAString& aPort, ErrorResult& aRv) const = 0;
+  GetPort(nsAString& aPort) const = 0;
 
   virtual void
-  SetPort(const nsAString& aPort, ErrorResult& aRv) = 0;
+  SetPort(const nsAString& aPort) = 0;
 
   virtual void
-  GetPathname(nsAString& aPathname, ErrorResult& aRv) const = 0;
+  GetPathname(nsAString& aPathname) const = 0;
 
   virtual void
-  SetPathname(const nsAString& aPathname, ErrorResult& aRv) = 0;
+  SetPathname(const nsAString& aPathname) = 0;
 
   virtual void
-  GetSearch(nsAString& aSearch, ErrorResult& aRv) const = 0;
+  GetSearch(nsAString& aSearch) const = 0;
 
   virtual void
-  SetSearch(const nsAString& aSearch, ErrorResult& aRv);
+  SetSearch(const nsAString& aSearch);
 
   URLSearchParams* SearchParams();
 
   virtual void
-  GetHash(nsAString& aHost, ErrorResult& aRv) const = 0;
+  GetHash(nsAString& aHost) const = 0;
 
   virtual void
-  SetHash(const nsAString& aHash, ErrorResult& aRv) = 0;
+  SetHash(const nsAString& aHash) = 0;
 
-  void Stringify(nsAString& aRetval, ErrorResult& aRv) const
+  void Stringify(nsAString& aRetval) const
   {
-    GetHref(aRetval, aRv);
+    GetHref(aRetval);
   }
 
   void
-  ToJSON(nsAString& aResult, ErrorResult& aRv) const
+  ToJSON(nsAString& aResult) const
   {
-    GetHref(aResult, aRv);
+    GetHref(aResult);
   }
 
   // URLSearchParamsObserver
   void
   URLSearchParamsUpdated(URLSearchParams* aSearchParams) override;
 
 protected:
   virtual ~URL()
   {}
 
   virtual void
   UpdateURLSearchParams() = 0;
 
   virtual void
-  SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) = 0;
+  SetSearchInternal(const nsAString& aSearch) = 0;
 
   void CreateSearchParamsIfNeeded();
 
   nsCOMPtr<nsISupports> mParent;
   RefPtr<URLSearchParams> mSearchParams;
 };
 
 bool IsChromeURI(nsIURI* aURI);

--- a/dom/url/URLMainThread.cpp
+++ b/dom/url/URLMainThread.cpp
@@ -179,17 +179,17 @@ URLMainThread::IsValidURL(const GlobalOb
                           ErrorResult& aRv)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_LossyConvertUTF16toASCII asciiurl(aURL);
   return nsHostObjectProtocolHandler::HasDataEntry(asciiurl);
 }
 
 void
-URLMainThread::GetHref(nsAString& aHref, ErrorResult& aRv) const
+URLMainThread::GetHref(nsAString& aHref) const
 {
   aHref.Truncate();
 
   nsAutoCString href;
   nsresult rv = mURI->GetSpec(href);
   if (NS_SUCCEEDED(rv)) {
     CopyUTF8toUTF16(href, aHref);
   }
@@ -220,17 +220,17 @@ URLMainThread::SetHref(const nsAString& 
 
 void
 URLMainThread::GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const
 {
   nsContentUtils::GetUTFOrigin(mURI, aOrigin);
 }
 
 void
-URLMainThread::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const
+URLMainThread::GetProtocol(nsAString& aProtocol) const
 {
   nsAutoCString protocol;
   if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {
     aProtocol.Truncate();
   }
 
   CopyASCIItoUTF16(protocol, aProtocol);
   aProtocol.Append(char16_t(':'));
@@ -276,51 +276,51 @@ URLMainThread::SetProtocol(const nsAStri
   value.Truncate();               \
   nsAutoCString tmp;              \
   nsresult rv = mURI->func(tmp);  \
   if (NS_SUCCEEDED(rv)) {         \
     CopyUTF8toUTF16(tmp, value);  \
   }
 
 void
-URLMainThread::GetUsername(nsAString& aUsername, ErrorResult& aRv) const
+URLMainThread::GetUsername(nsAString& aUsername) const
 {
   URL_GETTER(aUsername, GetUsername);
 }
 
 void
-URLMainThread::SetUsername(const nsAString& aUsername, ErrorResult& aRv)
+URLMainThread::SetUsername(const nsAString& aUsername)
 {
   Unused << NS_MutateURI(mURI)
               .SetUsername(NS_ConvertUTF16toUTF8(aUsername))
               .Finalize(mURI);
 }
 
 void
-URLMainThread::GetPassword(nsAString& aPassword, ErrorResult& aRv) const
+URLMainThread::GetPassword(nsAString& aPassword) const
 {
   URL_GETTER(aPassword, GetPassword);
 }
 
 void
-URLMainThread::SetPassword(const nsAString& aPassword, ErrorResult& aRv)
+URLMainThread::SetPassword(const nsAString& aPassword)
 {
   Unused << NS_MutateURI(mURI)
               .SetPassword(NS_ConvertUTF16toUTF8(aPassword))
               .Finalize(mURI);
 }
 
 void
-URLMainThread::GetHost(nsAString& aHost, ErrorResult& aRv) const
+URLMainThread::GetHost(nsAString& aHost) const
 {
   URL_GETTER(aHost, GetHostPort);
 }
 
 void
-URLMainThread::SetHost(const nsAString& aHost, ErrorResult& aRv)
+URLMainThread::SetHost(const nsAString& aHost)
 {
   Unused << NS_MutateURI(mURI)
               .SetHostPort(NS_ConvertUTF16toUTF8(aHost))
               .Finalize(mURI);
 }
 
 void
 URLMainThread::UpdateURLSearchParams()
@@ -334,48 +334,48 @@ URLMainThread::UpdateURLSearchParams()
   if (NS_WARN_IF(NS_FAILED(rv))) {
     search.Truncate();
   }
 
   mSearchParams->ParseInput(search);
 }
 
 void
-URLMainThread::GetHostname(nsAString& aHostname, ErrorResult& aRv) const
+URLMainThread::GetHostname(nsAString& aHostname) const
 {
   aHostname.Truncate();
   nsContentUtils::GetHostOrIPv6WithBrackets(mURI, aHostname);
 }
 
 void
-URLMainThread::SetHostname(const nsAString& aHostname, ErrorResult& aRv)
+URLMainThread::SetHostname(const nsAString& aHostname)
 {
   // nsStandardURL returns NS_ERROR_UNEXPECTED for an empty hostname
   // The return code is silently ignored
   mozilla::Unused << NS_MutateURI(mURI)
                        .SetHost(NS_ConvertUTF16toUTF8(aHostname))
                        .Finalize(mURI);
 }
 
 void
-URLMainThread::GetPort(nsAString& aPort, ErrorResult& aRv) const
+URLMainThread::GetPort(nsAString& aPort) const
 {
   aPort.Truncate();
 
   int32_t port;
   nsresult rv = mURI->GetPort(&port);
   if (NS_SUCCEEDED(rv) && port != -1) {
     nsAutoString portStr;
     portStr.AppendInt(port, 10);
     aPort.Assign(portStr);
   }
 }
 
 void
-URLMainThread::SetPort(const nsAString& aPort, ErrorResult& aRv)
+URLMainThread::SetPort(const nsAString& aPort)
 {
   nsresult rv;
   nsAutoString portStr(aPort);
   int32_t port = -1;
 
   // nsIURI uses -1 as default value.
   if (!portStr.IsEmpty()) {
     port = portStr.ToInteger(&rv);
@@ -385,42 +385,42 @@ URLMainThread::SetPort(const nsAString& 
   }
 
   Unused << NS_MutateURI(mURI)
               .SetPort(port)
               .Finalize(mURI);
 }
 
 void
-URLMainThread::GetPathname(nsAString& aPathname, ErrorResult& aRv) const
+URLMainThread::GetPathname(nsAString& aPathname) const
 {
   aPathname.Truncate();
 
   // Do not throw!  Not having a valid URI or URL should result in an empty
   // string.
 
   nsAutoCString file;
   nsresult rv = mURI->GetFilePath(file);
   if (NS_SUCCEEDED(rv)) {
     CopyUTF8toUTF16(file, aPathname);
   }
 }
 
 void
-URLMainThread::SetPathname(const nsAString& aPathname, ErrorResult& aRv)
+URLMainThread::SetPathname(const nsAString& aPathname)
 {
   // Do not throw!
 
   Unused << NS_MutateURI(mURI)
               .SetFilePath(NS_ConvertUTF16toUTF8(aPathname))
               .Finalize(mURI);
 }
 
 void
-URLMainThread::GetSearch(nsAString& aSearch, ErrorResult& aRv) const
+URLMainThread::GetSearch(nsAString& aSearch) const
 {
   aSearch.Truncate();
 
   // Do not throw!  Not having a valid URI or URL should result in an empty
   // string.
 
   nsAutoCString search;
   nsresult rv;
@@ -428,38 +428,38 @@ URLMainThread::GetSearch(nsAString& aSea
   rv = mURI->GetQuery(search);
   if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
     aSearch.Assign(u'?');
     AppendUTF8toUTF16(search, aSearch);
   }
 }
 
 void
-URLMainThread::GetHash(nsAString& aHash, ErrorResult& aRv) const
+URLMainThread::GetHash(nsAString& aHash) const
 {
   aHash.Truncate();
 
   nsAutoCString ref;
   nsresult rv = mURI->GetRef(ref);
   if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
     aHash.Assign(char16_t('#'));
     AppendUTF8toUTF16(ref, aHash);
   }
 }
 
 void
-URLMainThread::SetHash(const nsAString& aHash, ErrorResult& aRv)
+URLMainThread::SetHash(const nsAString& aHash)
 {
   Unused << NS_MutateURI(mURI)
               .SetRef(NS_ConvertUTF16toUTF8(aHash))
               .Finalize(mURI);
 }
 
 void
-URLMainThread::SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv)
+URLMainThread::SetSearchInternal(const nsAString& aSearch)
 {
   // Ignore failures to be compatible with NS4.
 
   Unused << NS_MutateURI(mURI)
               .SetQuery(NS_ConvertUTF16toUTF8(aSearch))
               .Finalize(mURI);
 }
 

--- a/dom/url/URLMainThread.h
+++ b/dom/url/URLMainThread.h
@@ -46,79 +46,79 @@ public:
 
   static bool
   IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
              ErrorResult& aRv);
 
   URLMainThread(nsISupports* aParent, already_AddRefed<nsIURI> aURI);
 
   virtual void
-  GetHref(nsAString& aHref, ErrorResult& aRv) const override;
+  GetHref(nsAString& aHref) const override;
 
   virtual void
   SetHref(const nsAString& aHref, ErrorResult& aRv) override;
 
   virtual void
   GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const override;
 
   virtual void
-  GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const override;
+  GetProtocol(nsAString& aProtocol) const override;
 
   virtual void
   SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) override;
 
   virtual void
-  GetUsername(nsAString& aUsername, ErrorResult& aRv) const override;
+  GetUsername(nsAString& aUsername) const override;
 
   virtual void
-  SetUsername(const nsAString& aUsername, ErrorResult& aRv) override;
+  SetUsername(const nsAString& aUsername) override;
 
   virtual void
-  GetPassword(nsAString& aPassword, ErrorResult& aRv) const override;
+  GetPassword(nsAString& aPassword) const override;
 
   virtual void
-  SetPassword(const nsAString& aPassword, ErrorResult& aRv) override;
+  SetPassword(const nsAString& aPassword) override;
 
   virtual void
-  GetHost(nsAString& aHost, ErrorResult& aRv) const override;
+  GetHost(nsAString& aHost) const override;
 
   virtual void
-  SetHost(const nsAString& aHost, ErrorResult& aRv) override;
+  SetHost(const nsAString& aHost) override;
 
   virtual void
-  GetHostname(nsAString& aHostname, ErrorResult& aRv) const override;
+  GetHostname(nsAString& aHostname) const override;
 
   virtual void
-  SetHostname(const nsAString& aHostname, ErrorResult& aRv) override;
+  SetHostname(const nsAString& aHostname) override;
 
   virtual void
-  GetPort(nsAString& aPort, ErrorResult& aRv) const override;
+  GetPort(nsAString& aPort) const override;
 
   virtual void
-  SetPort(const nsAString& aPort, ErrorResult& aRv) override;
+  SetPort(const nsAString& aPort) override;
 
   virtual void
-  GetPathname(nsAString& aPathname, ErrorResult& aRv) const override;
+  GetPathname(nsAString& aPathname) const override;
 
   virtual void
-  SetPathname(const nsAString& aPathname, ErrorResult& aRv) override;
+  SetPathname(const nsAString& aPathname) override;
 
   virtual void
-  GetSearch(nsAString& aSearch, ErrorResult& aRv) const override;
+  GetSearch(nsAString& aSearch) const override;
 
   virtual void
-  GetHash(nsAString& aHost, ErrorResult& aRv) const override;
+  GetHash(nsAString& aHost) const override;
 
   virtual void
-  SetHash(const nsAString& aHash, ErrorResult& aRv) override;
+  SetHash(const nsAString& aHash) override;
 
   virtual void UpdateURLSearchParams() override;
 
   virtual void
-  SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) override;
+  SetSearchInternal(const nsAString& aSearch) override;
 
   nsIURI*
   GetURI() const;
 
 private:
   ~URLMainThread();
 
   nsCOMPtr<nsIURI> mURI;

--- a/dom/url/URLWorker.cpp
+++ b/dom/url/URLWorker.cpp
@@ -7,16 +7,17 @@
 #include "URLWorker.h"
 
 #include "mozilla/dom/Blob.h"
 #include "mozilla/dom/WorkerPrivate.h"
 #include "mozilla/dom/WorkerRunnable.h"
 #include "mozilla/dom/WorkerScope.h"
 #include "mozilla/Unused.h"
 #include "nsHostObjectProtocolHandler.h"
+#include "nsProxyRelease.h"
 #include "nsStandardURL.h"
 #include "nsURLHelper.h"
 
 namespace mozilla {
 
 using net::nsStandardURL;
 
 namespace dom {
@@ -30,37 +31,23 @@ public:
   explicit URLProxy(already_AddRefed<URLMainThread> aURL)
     : mURL(aURL)
   {
     MOZ_ASSERT(NS_IsMainThread());
   }
 
   URLMainThread* URL()
   {
-    MOZ_ASSERT(NS_IsMainThread());
     return mURL;
   }
 
-  nsIURI* URI()
-  {
-    MOZ_ASSERT(NS_IsMainThread());
-    return mURL->GetURI();
-  }
-
-  void ReleaseURI()
-  {
-    MOZ_ASSERT(NS_IsMainThread());
-    mURL = nullptr;
-  }
-
 private:
-  // Private destructor, to discourage deletion outside of Release():
   ~URLProxy()
   {
-     MOZ_ASSERT(!mURL);
+    NS_ReleaseOnMainThreadSystemGroup("URLMainThread", mURL.forget());
   }
 
   RefPtr<URLMainThread> mURL;
 };
 
 // This class creates an URL from a DOM Blob on the main thread.
 class CreateURLRunnable : public WorkerMainThreadRunnable
 {
@@ -274,154 +261,59 @@ public:
     if (!mRetval) {
       aRv.ThrowTypeError<MSG_INVALID_URL>(mURL);
     }
 
     return mRetval;
   }
 };
 
-class TeardownURLRunnable : public Runnable
+class OriginGetterRunnable : public WorkerMainThreadRunnable
 {
 public:
-  explicit TeardownURLRunnable(URLWorker::URLProxy* aURLProxy)
-    : Runnable("dom::TeardownURLRunnable")
-    , mURLProxy(aURLProxy)
-  {
-  }
-
-  NS_IMETHOD Run() override
-  {
-    AssertIsOnMainThread();
-
-    mURLProxy->ReleaseURI();
-    mURLProxy = nullptr;
-
-    return NS_OK;
-  }
-
-private:
-  RefPtr<URLWorker::URLProxy> mURLProxy;
-};
-
-// This class is the generic getter for any URL property.
-class GetterRunnable : public WorkerMainThreadRunnable
-{
-public:
-  enum GetterType {
-    GetterHref,
-    GetterOrigin,
-    GetterProtocol,
-    GetterUsername,
-    GetterPassword,
-    GetterHost,
-    GetterHostname,
-    GetterPort,
-    GetterPathname,
-    GetterSearch,
-    GetterHash,
-  };
-
-  GetterRunnable(WorkerPrivate* aWorkerPrivate,
-                 GetterType aType, nsAString& aValue,
-                 URLWorker::URLProxy* aURLProxy)
+  OriginGetterRunnable(WorkerPrivate* aWorkerPrivate,
+                       nsAString& aValue,
+                       URLWorker::URLProxy* aURLProxy)
   : WorkerMainThreadRunnable(aWorkerPrivate,
                              // We can have telemetry keys for each getter when
                              // needed.
                              NS_LITERAL_CSTRING("URL :: getter"))
   , mValue(aValue)
-  , mType(aType)
   , mURLProxy(aURLProxy)
   {
     mWorkerPrivate->AssertIsOnWorkerThread();
   }
 
   bool
   MainThreadRun() override
   {
     AssertIsOnMainThread();
     ErrorResult rv;
-
-    switch (mType) {
-      case GetterHref:
-        mURLProxy->URL()->GetHref(mValue, rv);
-        break;
-
-      case GetterOrigin:
-        mURLProxy->URL()->GetOrigin(mValue, rv);
-        break;
-
-      case GetterProtocol:
-        mURLProxy->URL()->GetProtocol(mValue, rv);
-        break;
-
-      case GetterUsername:
-        mURLProxy->URL()->GetUsername(mValue, rv);
-        break;
-
-      case GetterPassword:
-        mURLProxy->URL()->GetPassword(mValue, rv);
-        break;
-
-      case GetterHost:
-        mURLProxy->URL()->GetHost(mValue, rv);
-        break;
-
-      case GetterHostname:
-        mURLProxy->URL()->GetHostname(mValue, rv);
-        break;
-
-      case GetterPort:
-        mURLProxy->URL()->GetPort(mValue, rv);
-        break;
-
-      case GetterPathname:
-        mURLProxy->URL()->GetPathname(mValue, rv);
-        break;
-
-      case GetterSearch:
-        mURLProxy->URL()->GetSearch(mValue, rv);
-        break;
-
-      case GetterHash:
-        mURLProxy->URL()->GetHash(mValue, rv);
-        break;
-    }
-
+    mURLProxy->URL()->GetOrigin(mValue, rv);
     MOZ_ASSERT(!rv.Failed(), "Main-thread getters do not fail.");
     return true;
   }
 
   void
   Dispatch(ErrorResult& aRv)
   {
     WorkerMainThreadRunnable::Dispatch(Terminating, aRv);
   }
 
 private:
   nsAString& mValue;
-  GetterType mType;
   RefPtr<URLWorker::URLProxy> mURLProxy;
 };
 
-// This class is the generic setter for any URL property.
 class SetterRunnable : public WorkerMainThreadRunnable
 {
 public:
   enum SetterType {
     SetterHref,
     SetterProtocol,
-    SetterUsername,
-    SetterPassword,
-    SetterHost,
-    SetterHostname,
-    SetterPort,
-    SetterPathname,
-    SetterSearch,
-    SetterHash,
   };
 
   SetterRunnable(WorkerPrivate* aWorkerPrivate,
                  SetterType aType, const nsAString& aValue,
                  URLWorker::URLProxy* aURLProxy)
   : WorkerMainThreadRunnable(aWorkerPrivate,
                              // We can have telemetry keys for each setter when
                              // needed.
@@ -444,48 +336,16 @@ public:
       case SetterHref: {
         mURLProxy->URL()->SetHref(mValue, rv);
         break;
       }
 
       case SetterProtocol:
         mURLProxy->URL()->SetProtocol(mValue, rv);
         break;
-
-      case SetterUsername:
-        mURLProxy->URL()->SetUsername(mValue, rv);
-        break;
-
-      case SetterPassword:
-        mURLProxy->URL()->SetPassword(mValue, rv);
-        break;
-
-      case SetterHost:
-        mURLProxy->URL()->SetHost(mValue, rv);
-        break;
-
-      case SetterHostname:
-        mURLProxy->URL()->SetHostname(mValue, rv);
-        break;
-
-      case SetterPort:
-        mURLProxy->URL()->SetPort(mValue, rv);
-        break;
-
-      case SetterPathname:
-        mURLProxy->URL()->SetPathname(mValue, rv);
-        break;
-
-      case SetterSearch:
-        mURLProxy->URL()->SetSearch(mValue, rv);
-        break;
-
-      case SetterHash:
-        mURLProxy->URL()->SetHash(mValue, rv);
-        break;
     }
 
     if (NS_WARN_IF(rv.Failed())) {
       rv.SuppressException();
       mFailed = true;
     }
 
     return true;
@@ -661,49 +521,33 @@ URLWorker::Init(const nsAString& aURL, c
     new ConstructorRunnable(mWorkerPrivate, aURL, aBase);
   runnable->Dispatch(Terminating, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
   mURLProxy = runnable->GetURLProxy(aRv);
 }
 
-URLWorker::~URLWorker()
-{
-  if (mURLProxy) {
-    mWorkerPrivate->AssertIsOnWorkerThread();
-
-    RefPtr<TeardownURLRunnable> runnable =
-      new TeardownURLRunnable(mURLProxy);
-    mURLProxy = nullptr;
-
-    if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
-      NS_ERROR("Failed to dispatch teardown runnable!");
-    }
-  }
-}
+URLWorker::~URLWorker() = default;
 
 void
-URLWorker::GetHref(nsAString& aHref, ErrorResult& aRv) const
+URLWorker::GetHref(nsAString& aHref) const
 {
   aHref.Truncate();
   if (mStdURL) {
     nsAutoCString href;
-    aRv = mStdURL->GetSpec(href);
-    if (!aRv.Failed()) {
+    nsresult rv = mStdURL->GetSpec(href);
+    if (NS_SUCCEEDED(rv)) {
       CopyUTF8toUTF16(href, aHref);
     }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHref, aHref,
-                       mURLProxy);
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetHref(aHref);
 }
 
 void
 URLWorker::SetHref(const nsAString& aHref, ErrorResult& aRv)
 {
   SetHrefInternal(aHref, eUseProxyIfNeeded, aRv);
 }
 
@@ -719,28 +563,17 @@ URLWorker::SetHrefInternal(const nsAStri
   }
 
   if (aStrategy == eUseProxyIfNeeded &&
       (scheme.EqualsLiteral("http") || scheme.EqualsLiteral("https"))) {
     nsCOMPtr<nsIURI> uri;
     aRv = NS_MutateURI(new nsStandardURL::Mutator())
             .SetSpec(NS_ConvertUTF16toUTF8(aHref))
             .Finalize(mStdURL);
-    if (mURLProxy) {
-      mWorkerPrivate->AssertIsOnWorkerThread();
-
-      RefPtr<TeardownURLRunnable> runnable =
-        new TeardownURLRunnable(mURLProxy);
-      mURLProxy = nullptr;
-
-      if (NS_WARN_IF(NS_FAILED(NS_DispatchToMainThread(runnable)))) {
-        return;
-      }
-    }
-
+    mURLProxy = nullptr;
     UpdateURLSearchParams();
     return;
   }
 
   mStdURL = nullptr;
   // fallback to using a main thread url proxy
   if (mURLProxy) {
     RefPtr<SetterRunnable> runnable =
@@ -772,43 +605,38 @@ void
 URLWorker::GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const
 {
   if (mStdURL) {
     nsContentUtils::GetUTFOrigin(mStdURL, aOrigin);
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterOrigin, aOrigin,
-                       mURLProxy);
+  RefPtr<OriginGetterRunnable> runnable =
+    new OriginGetterRunnable(mWorkerPrivate, aOrigin, mURLProxy);
 
   runnable->Dispatch(aRv);
 }
 
 void
-URLWorker::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const
+URLWorker::GetProtocol(nsAString& aProtocol) const
 {
   aProtocol.Truncate();
   nsAutoCString protocol;
   if (mStdURL) {
     if (NS_SUCCEEDED(mStdURL->GetScheme(protocol))) {
       CopyASCIItoUTF16(protocol, aProtocol);
       aProtocol.Append(char16_t(':'));
     }
 
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterProtocol, aProtocol,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetProtocol(aProtocol);
 }
 
 void
 URLWorker::SetProtocol(const nsAString& aProtocol, ErrorResult& aRv)
 {
   nsAString::const_iterator start, end;
   aProtocol.BeginReading(start);
   aProtocol.EndReading(end);
@@ -866,176 +694,123 @@ URLWorker::SetProtocol(const nsAString& 
     if (NS_SUCCEEDED(rv)) {             \
       CopyUTF8toUTF16(tmp, value);      \
     }                                   \
     return;                             \
   }
 
 #define STDURL_SETTER(value, method)                     \
   if (mStdURL) {                                         \
-    aRv = NS_MutateURI(mStdURL)                          \
-            .method(NS_ConvertUTF16toUTF8(value))        \
-            .Finalize(mStdURL);                          \
+    Unused << NS_MutateURI(mStdURL)                      \
+              .method(NS_ConvertUTF16toUTF8(value))      \
+              .Finalize(mStdURL);                        \
     return;                                              \
   }
 
 void
-URLWorker::GetUsername(nsAString& aUsername, ErrorResult& aRv) const
+URLWorker::GetUsername(nsAString& aUsername) const
 {
   STDURL_GETTER(aUsername, GetUsername);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterUsername, aUsername,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetUsername(aUsername);
 }
 
 void
-URLWorker::SetUsername(const nsAString& aUsername, ErrorResult& aRv)
+URLWorker::SetUsername(const nsAString& aUsername)
 {
   STDURL_SETTER(aUsername, SetUsername);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterUsername,
-                       aUsername, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetUsername(aUsername);
 }
 
 void
-URLWorker::GetPassword(nsAString& aPassword, ErrorResult& aRv) const
+URLWorker::GetPassword(nsAString& aPassword) const
 {
   STDURL_GETTER(aPassword, GetPassword);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPassword, aPassword,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetPassword(aPassword);
 }
 
 void
-URLWorker::SetPassword(const nsAString& aPassword, ErrorResult& aRv)
+URLWorker::SetPassword(const nsAString& aPassword)
 {
   STDURL_SETTER(aPassword, SetPassword);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPassword,
-                       aPassword, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetPassword(aPassword);
 }
 
 void
-URLWorker::GetHost(nsAString& aHost, ErrorResult& aRv) const
+URLWorker::GetHost(nsAString& aHost) const
 {
   STDURL_GETTER(aHost, GetHostPort);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHost, aHost,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetHost(aHost);
 }
 
 void
-URLWorker::SetHost(const nsAString& aHost, ErrorResult& aRv)
+URLWorker::SetHost(const nsAString& aHost)
 {
   STDURL_SETTER(aHost, SetHostPort);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHost,
-                       aHost, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetHost(aHost);
 }
 
 void
-URLWorker::GetHostname(nsAString& aHostname, ErrorResult& aRv) const
+URLWorker::GetHostname(nsAString& aHostname) const
 {
   aHostname.Truncate();
   if (mStdURL) {
-    aRv = nsContentUtils::GetHostOrIPv6WithBrackets(mStdURL, aHostname);
+    nsresult rv = nsContentUtils::GetHostOrIPv6WithBrackets(mStdURL, aHostname);
+    if (NS_FAILED(rv)) {
+      aHostname.Truncate();
+    }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHostname, aHostname,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetHostname(aHostname);
 }
 
 void
-URLWorker::SetHostname(const nsAString& aHostname, ErrorResult& aRv)
+URLWorker::SetHostname(const nsAString& aHostname)
 {
   STDURL_SETTER(aHostname, SetHost);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHostname,
-                       aHostname, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetHostname(aHostname);
 }
 
 void
-URLWorker::GetPort(nsAString& aPort, ErrorResult& aRv) const
+URLWorker::GetPort(nsAString& aPort) const
 {
   aPort.Truncate();
 
   if (mStdURL) {
     int32_t port;
     nsresult rv = mStdURL->GetPort(&port);
     if (NS_SUCCEEDED(rv) && port != -1) {
       nsAutoString portStr;
       portStr.AppendInt(port, 10);
       aPort.Assign(portStr);
     }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPort, aPort,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetPort(aPort);
 }
 
 void
-URLWorker::SetPort(const nsAString& aPort, ErrorResult& aRv)
+URLWorker::SetPort(const nsAString& aPort)
 {
   if (mStdURL) {
     nsresult rv;
     nsAutoString portStr(aPort);
     int32_t port = -1;
 
     // nsIURI uses -1 as default value.
     if (!portStr.IsEmpty()) {
@@ -1047,167 +822,113 @@ URLWorker::SetPort(const nsAString& aPor
 
     Unused << NS_MutateURI(mStdURL)
                 .SetPort(port)
                 .Finalize(mStdURL);
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPort,
-                       aPort, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetPort(aPort);
 }
 
 void
-URLWorker::GetPathname(nsAString& aPathname, ErrorResult& aRv) const
+URLWorker::GetPathname(nsAString& aPathname) const
 {
   aPathname.Truncate();
 
   if (mStdURL) {
     nsAutoCString file;
     nsresult rv = mStdURL->GetFilePath(file);
     if (NS_SUCCEEDED(rv)) {
       CopyUTF8toUTF16(file, aPathname);
     }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPathname,
-                       aPathname, mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetPathname(aPathname);
 }
 
 void
-URLWorker::SetPathname(const nsAString& aPathname, ErrorResult& aRv)
+URLWorker::SetPathname(const nsAString& aPathname)
 {
   STDURL_SETTER(aPathname, SetFilePath);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPathname,
-                       aPathname, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetPathname(aPathname);
 }
 
 void
-URLWorker::GetSearch(nsAString& aSearch, ErrorResult& aRv) const
+URLWorker::GetSearch(nsAString& aSearch) const
 {
   aSearch.Truncate();
 
   if (mStdURL) {
     nsAutoCString search;
     nsresult rv;
 
     rv = mStdURL->GetQuery(search);
     if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
       aSearch.Assign(u'?');
       AppendUTF8toUTF16(search, aSearch);
     }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterSearch, aSearch,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetSearch(aSearch);
 }
 
 void
-URLWorker::GetHash(nsAString& aHash, ErrorResult& aRv) const
+URLWorker::GetHash(nsAString& aHash) const
 {
   aHash.Truncate();
   if (mStdURL) {
     nsAutoCString ref;
     nsresult rv = mStdURL->GetRef(ref);
     if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
       aHash.Assign(char16_t('#'));
       AppendUTF8toUTF16(ref, aHash);
     }
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<GetterRunnable> runnable =
-    new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHash, aHash,
-                       mURLProxy);
-
-  runnable->Dispatch(aRv);
+  mURLProxy->URL()->GetHash(aHash);
 }
 
 void
-URLWorker::SetHash(const nsAString& aHash, ErrorResult& aRv)
+URLWorker::SetHash(const nsAString& aHash)
 {
   STDURL_SETTER(aHash, SetRef);
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHash,
-                       aHash, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetHash(aHash);
 }
 
 void
-URLWorker::SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv)
+URLWorker::SetSearchInternal(const nsAString& aSearch)
 {
   if (mStdURL) {
     // URLMainThread ignores failures here.
     Unused << NS_MutateURI(mStdURL)
                 .SetQuery(NS_ConvertUTF16toUTF8(aSearch))
                 .Finalize(mStdURL);
     return;
   }
 
   MOZ_ASSERT(mURLProxy);
-  RefPtr<SetterRunnable> runnable =
-    new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterSearch,
-                       aSearch, mURLProxy);
-
-  runnable->Dispatch(aRv);
-  if (NS_WARN_IF(aRv.Failed())) {
-    return;
-  }
-
-  MOZ_ASSERT(!runnable->Failed());
+  mURLProxy->URL()->SetSearch(aSearch);
 }
 
 void
 URLWorker::UpdateURLSearchParams()
 {
   if (mSearchParams) {
     nsAutoString search;
-
-    ErrorResult rv;
-    GetSearch(search, rv);
-    if (NS_WARN_IF(rv.Failed())) {
-      rv.SuppressException();
-    }
-
+    GetSearch(search);
     mSearchParams->ParseInput(NS_ConvertUTF16toUTF8(Substring(search, 1)));
   }
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/url/URLWorker.h
+++ b/dom/url/URLWorker.h
@@ -48,79 +48,79 @@ public:
 
   explicit URLWorker(WorkerPrivate* aWorkerPrivate);
 
   void
   Init(const nsAString& aURL, const Optional<nsAString>& aBase,
        ErrorResult& aRv);
 
   virtual void
-  GetHref(nsAString& aHref, ErrorResult& aRv) const override;
+  GetHref(nsAString& aHref) const override;
 
   virtual void
   SetHref(const nsAString& aHref, ErrorResult& aRv) override;
 
   virtual void
   GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const override;
 
   virtual void
-  GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const override;
+  GetProtocol(nsAString& aProtocol) const override;
 
   virtual void
   SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) override;
 
   virtual void
-  GetUsername(nsAString& aUsername, ErrorResult& aRv) const override;
+  GetUsername(nsAString& aUsername) const override;
 
   virtual void
-  SetUsername(const nsAString& aUsername, ErrorResult& aRv) override;
+  SetUsername(const nsAString& aUsername) override;
 
   virtual void
-  GetPassword(nsAString& aPassword, ErrorResult& aRv) const override;
+  GetPassword(nsAString& aPassword) const override;
 
   virtual void
-  SetPassword(const nsAString& aPassword, ErrorResult& aRv) override;
+  SetPassword(const nsAString& aPassword) override;
 
   virtual void
-  GetHost(nsAString& aHost, ErrorResult& aRv) const override;
+  GetHost(nsAString& aHost) const override;
 
   virtual void
-  SetHost(const nsAString& aHost, ErrorResult& aRv) override;
+  SetHost(const nsAString& aHost) override;
 
   virtual void
-  GetHostname(nsAString& aHostname, ErrorResult& aRv) const override;
+  GetHostname(nsAString& aHostname) const override;
 
   virtual void
-  SetHostname(const nsAString& aHostname, ErrorResult& aRv) override;
+  SetHostname(const nsAString& aHostname) override;
 
   virtual void
-  GetPort(nsAString& aPort, ErrorResult& aRv) const override;
+  GetPort(nsAString& aPort) const override;
 
   virtual void
-  SetPort(const nsAString& aPort, ErrorResult& aRv) override;
+  SetPort(const nsAString& aPort) override;
 
   virtual void
-  GetPathname(nsAString& aPathname, ErrorResult& aRv) const override;
+  GetPathname(nsAString& aPathname) const override;
 
   virtual void
-  SetPathname(const nsAString& aPathname, ErrorResult& aRv) override;
+  SetPathname(const nsAString& aPathname) override;
 
   virtual void
-  GetSearch(nsAString& aSearch, ErrorResult& aRv) const override;
+  GetSearch(nsAString& aSearch) const override;
 
   virtual void
-  GetHash(nsAString& aHost, ErrorResult& aRv) const override;
+  GetHash(nsAString& aHost) const override;
 
   virtual void
-  SetHash(const nsAString& aHash, ErrorResult& aRv) override;
+  SetHash(const nsAString& aHash) override;
 
   virtual void UpdateURLSearchParams() override;
 
   virtual void
-  SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) override;
+  SetSearchInternal(const nsAString& aSearch) override;
 
 private:
   ~URLWorker();
 
   enum Strategy {
     eAlwaysUseProxy,
     eUseProxyIfNeeded,
   };

--- a/dom/webidl/URL.webidl
+++ b/dom/webidl/URL.webidl
@@ -14,44 +14,35 @@
 
 [Constructor(USVString url, optional USVString base),
  Exposed=(Window,Worker,WorkerDebugger)]
 interface URL {
   // Bug 824857: no support for stringifier attributes yet.
   //  stringifier attribute USVString href;
 
   // Bug 824857 should remove this.
-  [Throws]
   stringifier;
 
-  [Throws]
+  [SetterThrows]
   attribute USVString href;
-  [Throws]
+  [GetterThrows]
   readonly attribute USVString origin;
-  [Throws]
+  [SetterThrows]
            attribute USVString protocol;
-  [Throws]
            attribute USVString username;
-  [Throws]
            attribute USVString password;
-  [Throws]
            attribute USVString host;
-  [Throws]
            attribute USVString hostname;
-  [Throws]
            attribute USVString port;
-  [Throws]
            attribute USVString pathname;
-  [Throws]
            attribute USVString search;
-  [SameObject] readonly attribute URLSearchParams searchParams;
-  [Throws]
+  [SameObject]
+  readonly attribute URLSearchParams searchParams;
            attribute USVString hash;
 
-  [Throws]
   USVString toJSON();
 };
 
 partial interface URL {
   [Throws]
   static DOMString createObjectURL(Blob blob);
   [Throws]
   static DOMString createObjectURL(MediaStream stream);

--- a/dom/xhr/XMLHttpRequestMainThread.cpp
+++ b/dom/xhr/XMLHttpRequestMainThread.cpp
@@ -242,30 +242,16 @@ XMLHttpRequestMainThread::~XMLHttpReques
   MOZ_ASSERT(!mFlagSyncLooping, "we rather crash than hang");
   mFlagSyncLooping = false;
 
   mResultJSON.setUndefined();
   mResultArrayBuffer = nullptr;
   mozilla::DropJSObjects(this);
 }
 
-/**
- * This Init method should only be called by C++ consumers.
- */
-nsresult
-XMLHttpRequestMainThread::Init(nsIPrincipal* aPrincipal,
-                               nsIGlobalObject* aGlobalObject,
-                               nsIURI* aBaseURI,
-                               nsILoadGroup* aLoadGroup)
-{
-  NS_ENSURE_ARG_POINTER(aPrincipal);
-  Construct(aPrincipal, aGlobalObject, aBaseURI, aLoadGroup);
-  return NS_OK;
-}
-
 void
 XMLHttpRequestMainThread::InitParameters(bool aAnon, bool aSystem)
 {
   if (!aAnon && !aSystem) {
     return;
   }
 
   // Check for permissions.