--- a/devtools/client/shared/test/browser.ini
+++ b/devtools/client/shared/test/browser.ini
@@ -26,16 +26,17 @@ support-files =
 [browser_css_angle.js]
 [browser_css_color.js]
 [browser_cubic-bezier-01.js]
 [browser_cubic-bezier-02.js]
 [browser_cubic-bezier-03.js]
 [browser_cubic-bezier-04.js]
 [browser_cubic-bezier-05.js]
 [browser_cubic-bezier-06.js]
+[browser_cubic-bezier-07.js]
 [browser_filter-editor-01.js]
 [browser_filter-editor-02.js]
 [browser_filter-editor-03.js]
 [browser_filter-editor-04.js]
 [browser_filter-editor-05.js]
 [browser_filter-editor-06.js]
 [browser_filter-editor-07.js]
 [browser_filter-editor-08.js]

new file mode 100644
--- /dev/null
+++ b/devtools/client/shared/test/browser_cubic-bezier-07.js
@@ -0,0 +1,53 @@
+/* vim: set ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Tests that changing the cubic-bezier curve in the widget does change the dot animation
+// preview too.
+
+const {CubicBezierWidget} = require("devtools/client/shared/widgets/CubicBezierWidget");
+const {PREDEFINED} = require("devtools/client/shared/widgets/CubicBezierPresets");
+
+const TEST_URI = `data:text/html,<div id="cubic-bezier-container" />`;
+
+add_task(function* () {
+  let [host,, doc] = yield createHost("bottom", TEST_URI);
+
+  let container = doc.querySelector("#cubic-bezier-container");
+  let w = new CubicBezierWidget(container, PREDEFINED.linear);
+
+  yield previewDotReactsToChanges(w, [0.6, -0.28, 0.74, 0.05]);
+  yield previewDotReactsToChanges(w, [0.9, 0.03, 0.69, 0.22]);
+  yield previewDotReactsToChanges(w, [0.68, -0.55, 0.27, 1.55]);
+  yield previewDotReactsToChanges(w, PREDEFINED.ease, "ease");
+  yield previewDotReactsToChanges(w, PREDEFINED["ease-in-out"], "ease-in-out");
+
+  w.destroy();
+  host.destroy();
+});
+
+function* previewDotReactsToChanges(widget, coords, expectedEasing) {
+  let onUpdated = widget.once("updated");
+  widget.coordinates = coords;
+  yield onUpdated;
+
+  let animatedDot = widget.timingPreview.dot;
+  let animations = animatedDot.getAnimations();
+
+  if (!expectedEasing) {
+    expectedEasing =
+      `cubic-bezier(${coords[0]}, ${coords[1]}, ${coords[2]}, ${coords[3]})`;
+  }
+
+  is(animations.length, 1, "The dot is animated");
+
+  let goingToRight = animations[0].effect.getKeyframes()[2];
+  is(goingToRight.easing, expectedEasing,
+     `The easing when going to the right was set correctly to ${coords}`);
+
+  let goingToLeft = animations[0].effect.getKeyframes()[6];
+  is(goingToLeft.easing, expectedEasing,
+     `The easing when going to the left was set correctly to ${coords}`);
+}

--- a/devtools/client/shared/widgets/CubicBezierWidget.js
+++ b/devtools/client/shared/widgets/CubicBezierWidget.js
@@ -413,17 +413,17 @@ CubicBezierWidget.prototype = {
    * @param {Array} coordinates The array of control point coordinates
    */
   _redraw: function (coordinates) {
     // Provide a new CubicBezier to the canvas and plot the curve
     this.bezierCanvas.bezier = new CubicBezier(coordinates);
     this.bezierCanvas.plot();
     this.emit("updated", this.bezierCanvas.bezier);
 
-    this.timingPreview.preview(this.bezierCanvas.bezier + "");
+    this.timingPreview.preview(this.bezierCanvas.bezier.toString());
   },
 
   /**
    * Set new coordinates for the control points and redraw the curve
    * @param {Array} coordinates
    */
   set coordinates(coordinates) {
     this._redraw(coordinates);
@@ -716,17 +716,16 @@ CubicBezierPresetWidget.prototype = {
 
 /**
  * The TimingFunctionPreviewWidget animates a dot on a scale with a given
  * timing-function
  * @param {DOMNode} parent The container where this widget should go
  */
 function TimingFunctionPreviewWidget(parent) {
   this.previousValue = null;
-  this.autoRestartAnimation = null;
 
   this.parent = parent;
   this._initMarkup();
 }
 
 TimingFunctionPreviewWidget.prototype = {
   PREVIEW_DURATION: 1000,
 
@@ -743,62 +742,69 @@ TimingFunctionPreviewWidget.prototype = 
     let scale = doc.createElementNS(XHTML_NS, "div");
     scale.className = "scale";
     container.appendChild(scale);
 
     this.parent.appendChild(container);
   },
 
   destroy: function () {
-    clearTimeout(this.autoRestartAnimation);
+    this.dot.getAnimations().forEach(anim => anim.cancel());
     this.parent.querySelector(".timing-function-preview").remove();
     this.parent = this.dot = null;
   },
 
   /**
    * Preview a new timing function. The current preview will only be stopped if
    * the supplied function value is different from the previous one. If the
    * supplied function is invalid, the preview will stop.
    * @param {String} value
    */
   preview: function (value) {
     // Don't restart the preview animation if the value is the same
     if (value === this.previousValue) {
       return;
     }
 
-    clearTimeout(this.autoRestartAnimation);
-
     if (parseTimingFunction(value)) {
-      this.dot.style.animationTimingFunction = value;
-      this.restartAnimation();
+      this.restartAnimation(value);
     }
 
     this.previousValue = value;
   },
 
   /**
-   * Re-start the preview animation from the beginning
+   * Re-start the preview animation from the beginning.
+   * @param {String} timingFunction The value for the timing-function.
    */
-  restartAnimation: function () {
-    // Just toggling the class won't do it unless there's a sync reflow
+  restartAnimation: function (timingFunction) {
+    // Cancel the previous animation if there was any.
+    this.dot.getAnimations().forEach(anim => anim.cancel());
+
+    // And start the new one.
+    // The animation consists of a few keyframes that move the dot to the right of the
+    // container, and then move it back to the left.
+    // It also contains some pause where the dot is semi transparent, before it moves to
+    // the right, and once again, before it comes back to the left.
+    // The timing function passed to this function is applied to the keyframes that
+    // actually move the dot. This way it can be previewed in both direction, instead of
+    // being spread over the whole animation.
     this.dot.animate([
-      { left: "-7px", offset: 0 },
-      { left: "143px", offset: 0.25 },
-      { left: "143px", offset: 0.5 },
-      { left: "-7px", offset: 0.75 },
-      { left: "-7px", offset: 1 }
+      { left: "-7px", opacity: .5, offset: 0 },
+      { left: "-7px", opacity: .5, offset: .19 },
+      { left: "-7px", opacity: 1, offset: .2, easing: timingFunction },
+      { left: "143px", opacity: 1, offset: .5 },
+      { left: "143px", opacity: .5, offset: .51 },
+      { left: "143px", opacity: .5, offset: .7 },
+      { left: "143px", opacity: 1, offset: .71, easing: timingFunction },
+      { left: "-7px", opacity: 1, offset: 1 }
     ], {
-      duration: (this.PREVIEW_DURATION * 2),
-      fill: "forwards"
+      duration: this.PREVIEW_DURATION * 2,
+      iterations: Infinity
     });
-
-    // Restart it again after a while
-    this.autoRestartAnimation = setTimeout(this.restartAnimation.bind(this),
-      this.PREVIEW_DURATION * 2);
   }
 };
 
 // Helpers
 
 function getPadding(padding) {
   let p = typeof padding === "number" ? [padding] : padding;
 

--- a/dom/base/nsDeprecatedOperationList.h
+++ b/dom/base/nsDeprecatedOperationList.h
@@ -45,8 +45,9 @@ DEPRECATED_OPERATION(NavigatorGetUserMed
 DEPRECATED_OPERATION(WebrtcDeprecatedPrefix)
 DEPRECATED_OPERATION(RTCPeerConnectionGetStreams)
 DEPRECATED_OPERATION(AppCache)
 DEPRECATED_OPERATION(PrefixedImageSmoothingEnabled)
 DEPRECATED_OPERATION(PrefixedFullscreenAPI)
 DEPRECATED_OPERATION(LenientSetter)
 DEPRECATED_OPERATION(FileLastModifiedDate)
 DEPRECATED_OPERATION(ImageBitmapRenderingContext_TransferImageBitmap)
+DEPRECATED_OPERATION(URLCreateObjectURL_MediaStream)

--- a/dom/bindings/BindingUtils.cpp
+++ b/dom/bindings/BindingUtils.cpp
@@ -3613,26 +3613,33 @@ DeprecationWarning(JSContext* aCx, JSObj
                    nsIDocument::DeprecatedOperations aOperation)
 {
   GlobalObject global(aCx, aObject);
   if (global.Failed()) {
     NS_ERROR("Could not create global for DeprecationWarning");
     return;
   }
 
+  DeprecationWarning(global, aOperation);
+}
+
+void
+DeprecationWarning(const GlobalObject& aGlobal,
+                   nsIDocument::DeprecatedOperations aOperation)
+{
   if (NS_IsMainThread()) {
-    nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(global.GetAsSupports());
+    nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal.GetAsSupports());
     if (window && window->GetExtantDoc()) {
       window->GetExtantDoc()->WarnOnceAbout(aOperation);
     }
 
     return;
   }
 
-  WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);
+  WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aGlobal.Context());
   if (!workerPrivate) {
     return;
   }
 
   RefPtr<DeprecationWarningRunnable> runnable =
     new DeprecationWarningRunnable(workerPrivate, aOperation);
   runnable->Dispatch();
 }

--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -3190,16 +3190,20 @@ void
 SetDocumentAndPageUseCounter(JSContext* aCx, JSObject* aObject,
                              UseCounter aUseCounter);
 
 // Warnings
 void
 DeprecationWarning(JSContext* aCx, JSObject* aObject,
                    nsIDocument::DeprecatedOperations aOperation);
 
+void
+DeprecationWarning(const GlobalObject& aGlobal,
+                   nsIDocument::DeprecatedOperations aOperation);
+
 // A callback to perform funToString on an interface object
 JSString*
 InterfaceObjectToString(JSContext* aCx, JS::Handle<JSObject*> aObject,
                         unsigned /* indent */);
 
 namespace binding_detail {
 // Get a JS global object that can be used for some temporary allocations.  The
 // idea is that this should be used for situations when you need to operate in

--- a/dom/browser-element/mochitest/chrome.ini
+++ b/dom/browser-element/mochitest/chrome.ini
@@ -54,17 +54,17 @@ support-files =
 [test_browserElement_inproc_ActiveStateChange.html]
 tags = audiochannel
 [test_browserElement_inproc_AudioChannelMutedByDefault.html]
 tags = audiochannel
 skip-if = toolkit == 'android'
 [test_browserElement_inproc_AudioChannelSeeking.html]
 tags = audiochannel
 [test_browserElement_inproc_AudioPlayback.html]
-skip-if = toolkit == 'android' # bug 1332850
+skip-if = true # bug 1332850, bug 1332862
 [test_browserElement_inproc_AudioChannel.html]
 tags = audiochannel
 [test_browserElement_inproc_AudioChannel_nested.html]
 tags = audiochannel
 skip-if = toolkit == 'android' # bug 1332850
 [test_browserElement_inproc_BackForward.html]
 [test_browserElement_inproc_BadScreenshot.html]
 [test_browserElement_inproc_DocumentFirstPaint.html]

new file mode 100644
--- /dev/null
+++ b/dom/canvas/BasicRenderingContext2D.h
@@ -0,0 +1,201 @@
+/* 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/. */
+
+#ifndef BasicRenderingContext2D_h
+#define BasicRenderingContext2D_h
+
+#include "mozilla/dom/CanvasRenderingContext2DBinding.h"
+
+namespace mozilla {
+namespace dom {
+
+class HTMLImageElementOrHTMLCanvasElementOrHTMLVideoElementOrImageBitmap;
+typedef HTMLImageElementOrHTMLCanvasElementOrHTMLVideoElementOrImageBitmap
+  CanvasImageSource;
+
+/*
+ * BasicRenderingContext2D
+ */
+class BasicRenderingContext2D
+{
+public:
+  //
+  // CanvasState
+  //
+  virtual void Save() = 0;
+  virtual void Restore() = 0;
+
+  //
+  // CanvasTransform
+  //
+  virtual void Scale(double aX, double aY, mozilla::ErrorResult& aError) = 0;
+  virtual void Rotate(double aAngle, mozilla::ErrorResult& aError) = 0;
+  virtual void Translate(double aX,
+                         double aY,
+                         mozilla::ErrorResult& aError) = 0;
+  virtual void Transform(double aM11,
+                         double aM12,
+                         double aM21,
+                         double aM22,
+                         double aDx,
+                         double aDy,
+                         mozilla::ErrorResult& aError) = 0;
+  virtual void SetTransform(double aM11,
+                            double aM12,
+                            double aM21,
+                            double aM22,
+                            double aDx,
+                            double aDy,
+                            mozilla::ErrorResult& aError) = 0;
+  virtual void ResetTransform(mozilla::ErrorResult& aError) = 0;
+
+  //
+  // CanvasCompositing
+  //
+  virtual double GlobalAlpha() = 0;
+  virtual void SetGlobalAlpha(double aGlobalAlpha) = 0;
+  virtual void GetGlobalCompositeOperation(nsAString& aOp,
+                                           mozilla::ErrorResult& aError) = 0;
+  virtual void SetGlobalCompositeOperation(const nsAString& aOp,
+                                           mozilla::ErrorResult& aError) = 0;
+
+  //
+  // CanvasImageSmoothing
+  //
+  virtual bool ImageSmoothingEnabled() = 0;
+  virtual void SetImageSmoothingEnabled(bool aImageSmoothingEnabled) = 0;
+
+  //
+  // CanvasFillStrokeStyles
+  //
+  virtual void GetStrokeStyle(
+    OwningStringOrCanvasGradientOrCanvasPattern& aValue) = 0;
+  virtual void SetStrokeStyle(
+    const StringOrCanvasGradientOrCanvasPattern& aValue) = 0;
+  virtual void GetFillStyle(
+    OwningStringOrCanvasGradientOrCanvasPattern& aValue) = 0;
+  virtual void SetFillStyle(
+    const StringOrCanvasGradientOrCanvasPattern& aValue) = 0;
+  virtual already_AddRefed<CanvasGradient> CreateLinearGradient(double aX0,
+                                                                double aY0,
+                                                                double aX1,
+                                                                double aY1) = 0;
+  virtual already_AddRefed<CanvasGradient> CreateRadialGradient(
+    double aX0,
+    double aY0,
+    double aR0,
+    double aX1,
+    double aY1,
+    double aR1,
+    ErrorResult& aError) = 0;
+  virtual already_AddRefed<CanvasPattern> CreatePattern(
+    const CanvasImageSource& aElement,
+    const nsAString& aRepeat,
+    ErrorResult& aError) = 0;
+  //
+  // CanvasShadowStyles
+  //
+  virtual double ShadowOffsetX() = 0;
+  virtual void SetShadowOffsetX(double aShadowOffsetX) = 0;
+  virtual double ShadowOffsetY() = 0;
+  virtual void SetShadowOffsetY(double aShadowOffsetY) = 0;
+  virtual double ShadowBlur() = 0;
+  virtual void SetShadowBlur(double aShadowBlur) = 0;
+  virtual void GetShadowColor(nsAString& aShadowColor) = 0;
+  virtual void SetShadowColor(const nsAString& aShadowColor) = 0;
+
+  //
+  // CanvasRect
+  //
+  virtual void ClearRect(double aX, double aY, double aW, double aH) = 0;
+  virtual void FillRect(double aX, double aY, double aW, double aH) = 0;
+  virtual void StrokeRect(double aX, double aY, double aW, double aH) = 0;
+
+  //
+  // CanvasDrawImage
+  //
+  virtual void DrawImage(const CanvasImageSource& aImage,
+                         double aDx,
+                         double aDy,
+                         mozilla::ErrorResult& aError) = 0;
+  virtual void DrawImage(const CanvasImageSource& aImage,
+                         double aDx,
+                         double aDy,
+                         double aDw,
+                         double aDh,
+                         mozilla::ErrorResult& aError) = 0;
+  virtual void DrawImage(const CanvasImageSource& aImage,
+                         double aSx,
+                         double aSy,
+                         double aSw,
+                         double aSh,
+                         double aDx,
+                         double aDy,
+                         double aDw,
+                         double aDh,
+                         mozilla::ErrorResult& aError) = 0;
+
+  //
+  // CanvasPathDrawingStyles
+  //
+  virtual double LineWidth() = 0;
+  virtual void SetLineWidth(double aWidth) = 0;
+  virtual void GetLineCap(nsAString& aLinecapStyle) = 0;
+  virtual void SetLineCap(const nsAString& aLinecapStyle) = 0;
+  virtual void GetLineJoin(nsAString& aLinejoinStyle,
+                           mozilla::ErrorResult& aError) = 0;
+  virtual void SetLineJoin(const nsAString& aLinejoinStyle) = 0;
+  virtual double MiterLimit() = 0;
+  virtual void SetMiterLimit(double aMiter) = 0;
+  virtual void SetLineDash(const Sequence<double>& aSegments,
+                           mozilla::ErrorResult& aRv) = 0;
+  virtual void GetLineDash(nsTArray<double>& aSegments) const = 0;
+  virtual void SetLineDashOffset(double aOffset) = 0;
+  virtual double LineDashOffset() const = 0;
+
+  //
+  // CanvasPath
+  //
+  virtual void ClosePath() = 0;
+  virtual void MoveTo(double aX, double aY) = 0;
+  virtual void LineTo(double aX, double aY) = 0;
+  virtual void QuadraticCurveTo(double aCpx,
+                                double aCpy,
+                                double aX,
+                                double aY) = 0;
+  virtual void BezierCurveTo(double aCp1x,
+                             double aCp1y,
+                             double aCp2x,
+                             double aCp2y,
+                             double aX,
+                             double aY) = 0;
+  virtual void ArcTo(double aX1,
+                     double aY1,
+                     double aX2,
+                     double aY2,
+                     double aRadius,
+                     mozilla::ErrorResult& aError) = 0;
+  virtual void Rect(double aX, double aY, double aW, double aH) = 0;
+  virtual void Arc(double aX,
+                   double aY,
+                   double aRadius,
+                   double aStartAngle,
+                   double aEndAngle,
+                   bool aAnticlockwise,
+                   mozilla::ErrorResult& aError) = 0;
+  virtual void Ellipse(double aX,
+                       double aY,
+                       double aRadiusX,
+                       double aRadiusY,
+                       double aRotation,
+                       double aStartAngle,
+                       double aEndAngle,
+                       bool aAnticlockwise,
+                       ErrorResult& aError) = 0;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif /* BasicRenderingContext2D_h */

--- a/dom/canvas/CanvasRenderingContext2D.h
+++ b/dom/canvas/CanvasRenderingContext2D.h
@@ -10,16 +10,17 @@
 #include "nsIDOMCanvasRenderingContext2D.h"
 #include "nsICanvasRenderingContextInternal.h"
 #include "mozilla/RefPtr.h"
 #include "nsColor.h"
 #include "mozilla/dom/HTMLCanvasElement.h"
 #include "mozilla/dom/HTMLVideoElement.h"
 #include "gfxTextRun.h"
 #include "mozilla/ErrorResult.h"
+#include "mozilla/dom/BasicRenderingContext2D.h"
 #include "mozilla/dom/CanvasGradient.h"
 #include "mozilla/dom/CanvasRenderingContext2DBinding.h"
 #include "mozilla/dom/CanvasPattern.h"
 #include "mozilla/gfx/Rect.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/UniquePtr.h"
 #include "gfx2DGlue.h"
 #include "imgIEncoder.h"
@@ -56,17 +57,18 @@ class CanvasRenderingContext2DUserData;
 class CanvasDrawObserver;
 class CanvasShutdownObserver;
 
 /**
  ** CanvasRenderingContext2D
  **/
 class CanvasRenderingContext2D final :
   public nsICanvasRenderingContextInternal,
-  public nsWrapperCache
+  public nsWrapperCache,
+  public BasicRenderingContext2D
 {
   virtual ~CanvasRenderingContext2D();
 
 public:
   explicit CanvasRenderingContext2D(layers::LayersBackend aCompositorBackend);
 
   virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override;
 
@@ -75,122 +77,128 @@ public:
     if (!mCanvasElement || mCanvasElement->IsInNativeAnonymousSubtree()) {
       return nullptr;
     }
 
     // corresponds to changes to the old bindings made in bug 745025
     return mCanvasElement->GetOriginalCanvas();
   }
 
-  void Save();
-  void Restore();
-  void Scale(double aX, double aY, mozilla::ErrorResult& aError);
-  void Rotate(double aAngle, mozilla::ErrorResult& aError);
-  void Translate(double aX, double aY, mozilla::ErrorResult& aError);
-  void Transform(double aM11, double aM12, double aM21, double aM22, double aDx,
-                 double aDy, mozilla::ErrorResult& aError);
-  void SetTransform(double aM11, double aM12, double aM21, double aM22, double aDx,
-                    double aDy, mozilla::ErrorResult& aError);
-  void ResetTransform(mozilla::ErrorResult& aError);
+  void Save() override;
+  void Restore() override;
+  void Scale(double aX, double aY, mozilla::ErrorResult& aError) override;
+  void Rotate(double aAngle, mozilla::ErrorResult& aError) override;
+  void Translate(double aX, double aY, mozilla::ErrorResult& aError) override;
+  void Transform(double aM11, double aM12, double aM21, double aM22,
+                 double aDx, double aDy, mozilla::ErrorResult& aError) override;
+  void SetTransform(double aM11, double aM12, double aM21, double aM22,
+                    double aDx, double aDy, mozilla::ErrorResult& aError) override;
+  void ResetTransform(mozilla::ErrorResult& aError) override;
 
-  double GlobalAlpha()
+  double GlobalAlpha() override
   {
     return CurrentState().globalAlpha;
   }
 
   // Useful for silencing cast warnings
   static mozilla::gfx::Float ToFloat(double aValue) { return mozilla::gfx::Float(aValue); }
 
-  void SetGlobalAlpha(double aGlobalAlpha)
+  void SetGlobalAlpha(double aGlobalAlpha) override
   {
     if (aGlobalAlpha >= 0.0 && aGlobalAlpha <= 1.0) {
       CurrentState().globalAlpha = ToFloat(aGlobalAlpha);
     }
   }
 
-  void GetGlobalCompositeOperation(nsAString& aOp, mozilla::ErrorResult& aError);
+  void GetGlobalCompositeOperation(nsAString& aOp,
+                                   mozilla::ErrorResult& aError) override;
   void SetGlobalCompositeOperation(const nsAString& aOp,
-                                   mozilla::ErrorResult& aError);
+                                   mozilla::ErrorResult& aError) override;
 
-  void GetStrokeStyle(OwningStringOrCanvasGradientOrCanvasPattern& aValue)
+  void
+  GetStrokeStyle(OwningStringOrCanvasGradientOrCanvasPattern& aValue) override
   {
     GetStyleAsUnion(aValue, Style::STROKE);
   }
 
-  void SetStrokeStyle(const StringOrCanvasGradientOrCanvasPattern& aValue)
+  void
+  SetStrokeStyle(const StringOrCanvasGradientOrCanvasPattern& aValue) override
   {
     SetStyleFromUnion(aValue, Style::STROKE);
   }
 
-  void GetFillStyle(OwningStringOrCanvasGradientOrCanvasPattern& aValue)
+  void
+  GetFillStyle(OwningStringOrCanvasGradientOrCanvasPattern& aValue) override
   {
     GetStyleAsUnion(aValue, Style::FILL);
   }
 
-  void SetFillStyle(const StringOrCanvasGradientOrCanvasPattern& aValue)
+  void
+  SetFillStyle(const StringOrCanvasGradientOrCanvasPattern& aValue) override
   {
     SetStyleFromUnion(aValue, Style::FILL);
   }
 
   already_AddRefed<CanvasGradient>
-    CreateLinearGradient(double aX0, double aY0, double aX1, double aY1);
+    CreateLinearGradient(double aX0, double aY0, double aX1, double aY1) override;
   already_AddRefed<CanvasGradient>
-    CreateRadialGradient(double aX0, double aY0, double aR0, double aX1, double aY1,
-                         double aR1, ErrorResult& aError);
+    CreateRadialGradient(double aX0, double aY0, double aR0,
+                         double aX1, double aY1, double aR1,
+                         ErrorResult& aError) override;
   already_AddRefed<CanvasPattern>
     CreatePattern(const CanvasImageSource& aElement,
-                  const nsAString& aRepeat, ErrorResult& aError);
+                  const nsAString& aRepeat, ErrorResult& aError) override;
 
-  double ShadowOffsetX()
+  double ShadowOffsetX() override
   {
     return CurrentState().shadowOffset.x;
   }
 
-  void SetShadowOffsetX(double aShadowOffsetX)
+  void SetShadowOffsetX(double aShadowOffsetX) override
   {
     CurrentState().shadowOffset.x = ToFloat(aShadowOffsetX);
   }
 
-  double ShadowOffsetY()
+  double ShadowOffsetY() override
   {
     return CurrentState().shadowOffset.y;
   }
 
-  void SetShadowOffsetY(double aShadowOffsetY)
+  void SetShadowOffsetY(double aShadowOffsetY) override
   {
     CurrentState().shadowOffset.y = ToFloat(aShadowOffsetY);
   }
 
-  double ShadowBlur()
+  double ShadowBlur() override
   {
     return CurrentState().shadowBlur;
   }
 
-  void SetShadowBlur(double aShadowBlur)
+  void SetShadowBlur(double aShadowBlur) override
   {
     if (aShadowBlur >= 0.0) {
       CurrentState().shadowBlur = ToFloat(aShadowBlur);
     }
   }
 
-  void GetShadowColor(nsAString& aShadowColor)
+  void GetShadowColor(nsAString& aShadowColor) override
   {
     StyleColorToString(CurrentState().shadowColor, aShadowColor);
   }
 
   void GetFilter(nsAString& aFilter)
   {
     aFilter = CurrentState().filterString;
   }
 
-  void SetShadowColor(const nsAString& aShadowColor);
+  void SetShadowColor(const nsAString& aShadowColor) override;
   void SetFilter(const nsAString& aFilter, mozilla::ErrorResult& aError);
-  void ClearRect(double aX, double aY, double aW, double aH);
-  void FillRect(double aX, double aY, double aW, double aH);
-  void StrokeRect(double aX, double aY, double aW, double aH);
+  void ClearRect(double aX, double aY, double aW, double aH) override;
+  void FillRect(double aX, double aY, double aW, double aH) override;
+  void StrokeRect(double aX, double aY, double aW, double aH) override;
   void BeginPath();
   void Fill(const CanvasWindingRule& aWinding);
   void Fill(const CanvasPath& aPath, const CanvasWindingRule& aWinding);
   void Stroke();
   void Stroke(const CanvasPath& aPath);
   void DrawFocusIfNeeded(mozilla::dom::Element& aElement, ErrorResult& aRv);
   bool DrawCustomFocusRing(mozilla::dom::Element& aElement);
   void Clip(const CanvasWindingRule& aWinding);
@@ -207,32 +215,32 @@ public:
                   mozilla::ErrorResult& aError);
   TextMetrics*
     MeasureText(const nsAString& aRawText, mozilla::ErrorResult& aError);
 
   void AddHitRegion(const HitRegionOptions& aOptions, mozilla::ErrorResult& aError);
   void RemoveHitRegion(const nsAString& aId);
   void ClearHitRegions();
 
-  void DrawImage(const CanvasImageSource& aImage,
-                 double aDx, double aDy, mozilla::ErrorResult& aError)
+  void DrawImage(const CanvasImageSource& aImage, double aDx, double aDy,
+                 mozilla::ErrorResult& aError) override
   {
     DrawImage(aImage, 0.0, 0.0, 0.0, 0.0, aDx, aDy, 0.0, 0.0, 0, aError);
   }
 
-  void DrawImage(const CanvasImageSource& aImage,
-                 double aDx, double aDy, double aDw, double aDh,
-                 mozilla::ErrorResult& aError)
+  void DrawImage(const CanvasImageSource& aImage, double aDx, double aDy,
+                 double aDw, double aDh, mozilla::ErrorResult& aError) override
   {
     DrawImage(aImage, 0.0, 0.0, 0.0, 0.0, aDx, aDy, aDw, aDh, 2, aError);
   }
 
   void DrawImage(const CanvasImageSource& aImage,
-                 double aSx, double aSy, double aSw, double aSh, double aDx,
-                 double aDy, double aDw, double aDh, mozilla::ErrorResult& aError)
+                 double aSx, double aSy, double aSw, double aSh,
+                 double aDx, double aDy, double aDw, double aDh,
+                 mozilla::ErrorResult& aError) override
   {
     DrawImage(aImage, aSx, aSy, aSw, aSh, aDx, aDy, aDw, aDh, 6, aError);
   }
 
   already_AddRefed<ImageData>
     CreateImageData(JSContext* aCx, double aSw, double aSh,
                     mozilla::ErrorResult& aError);
   already_AddRefed<ImageData>
@@ -243,38 +251,39 @@ public:
                  mozilla::ErrorResult& aError);
   void PutImageData(ImageData& aImageData,
                     double aDx, double aDy, mozilla::ErrorResult& aError);
   void PutImageData(ImageData& aImageData,
                     double aDx, double aDy, double aDirtyX, double aDirtyY,
                     double aDirtyWidth, double aDirtyHeight,
                     mozilla::ErrorResult& aError);
 
-  double LineWidth()
+  double LineWidth() override
   {
     return CurrentState().lineWidth;
   }
 
-  void SetLineWidth(double aWidth)
+  void SetLineWidth(double aWidth) override
   {
     if (aWidth > 0.0) {
       CurrentState().lineWidth = ToFloat(aWidth);
     }
   }
-  void GetLineCap(nsAString& aLinecapStyle);
-  void SetLineCap(const nsAString& aLinecapStyle);
-  void GetLineJoin(nsAString& aLinejoinStyle, mozilla::ErrorResult& aError);
-  void SetLineJoin(const nsAString& aLinejoinStyle);
+  void GetLineCap(nsAString& aLinecapStyle) override;
+  void SetLineCap(const nsAString& aLinecapStyle) override;
+  void GetLineJoin(nsAString& aLinejoinStyle,
+                   mozilla::ErrorResult& aError) override;
+  void SetLineJoin(const nsAString& aLinejoinStyle) override;
 
-  double MiterLimit()
+  double MiterLimit() override
   {
     return CurrentState().miterLimit;
   }
 
-  void SetMiterLimit(double aMiter)
+  void SetMiterLimit(double aMiter) override
   {
     if (aMiter > 0.0) {
       CurrentState().miterLimit = ToFloat(aMiter);
     }
   }
 
   void GetFont(nsAString& aFont)
   {
@@ -282,79 +291,81 @@ public:
   }
 
   void SetFont(const nsAString& aFont, mozilla::ErrorResult& aError);
   void GetTextAlign(nsAString& aTextAlign);
   void SetTextAlign(const nsAString& aTextAlign);
   void GetTextBaseline(nsAString& aTextBaseline);
   void SetTextBaseline(const nsAString& aTextBaseline);
 
-  void ClosePath()
+  void ClosePath() override
   {
     EnsureWritablePath();
 
     if (mPathBuilder) {
       mPathBuilder->Close();
     } else {
       mDSPathBuilder->Close();
     }
   }
 
-  void MoveTo(double aX, double aY)
+  void MoveTo(double aX, double aY) override
   {
     EnsureWritablePath();
 
     if (mPathBuilder) {
       mPathBuilder->MoveTo(mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
     } else {
       mDSPathBuilder->MoveTo(mTarget->GetTransform().TransformPoint(
                              mozilla::gfx::Point(ToFloat(aX), ToFloat(aY))));
     }
   }
 
-  void LineTo(double aX, double aY)
+  void LineTo(double aX, double aY) override
   {
     EnsureWritablePath();
 
     LineTo(mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
   }
 
-  void QuadraticCurveTo(double aCpx, double aCpy, double aX, double aY)
+  void QuadraticCurveTo(double aCpx, double aCpy, double aX, double aY) override
   {
     EnsureWritablePath();
 
     if (mPathBuilder) {
       mPathBuilder->QuadraticBezierTo(mozilla::gfx::Point(ToFloat(aCpx), ToFloat(aCpy)),
                                       mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
     } else {
       mozilla::gfx::Matrix transform = mTarget->GetTransform();
       mDSPathBuilder->QuadraticBezierTo(transform.TransformPoint(
                                           mozilla::gfx::Point(ToFloat(aCpx), ToFloat(aCpy))),
                                         transform.TransformPoint(
                                           mozilla::gfx::Point(ToFloat(aX), ToFloat(aY))));
     }
   }
 
-  void BezierCurveTo(double aCp1x, double aCp1y, double aCp2x, double aCp2y, double aX, double aY)
+  void BezierCurveTo(double aCp1x, double aCp1y, double aCp2x, double aCp2y,
+                     double aX, double aY) override
   {
     EnsureWritablePath();
 
     BezierTo(mozilla::gfx::Point(ToFloat(aCp1x), ToFloat(aCp1y)),
              mozilla::gfx::Point(ToFloat(aCp2x), ToFloat(aCp2y)),
              mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
   }
 
-  void ArcTo(double aX1, double aY1, double aX2, double aY2, double aRadius,
-             mozilla::ErrorResult& aError);
-  void Rect(double aX, double aY, double aW, double aH);
+  void ArcTo(double aX1, double aY1, double aX2, double aY2,
+             double aRadius, mozilla::ErrorResult& aError) override;
+  void Rect(double aX, double aY, double aW, double aH) override;
   void Arc(double aX, double aY, double aRadius, double aStartAngle,
-           double aEndAngle, bool aAnticlockwise, mozilla::ErrorResult& aError);
+           double aEndAngle, bool aAnticlockwise,
+           mozilla::ErrorResult& aError) override;
   void Ellipse(double aX, double aY, double aRadiusX, double aRadiusY,
                double aRotation, double aStartAngle, double aEndAngle,
-               bool aAnticlockwise, ErrorResult& aError);
+               bool aAnticlockwise, ErrorResult& aError) override;
 
   void GetMozCurrentTransform(JSContext* aCx,
                               JS::MutableHandle<JSObject*> aResult,
                               mozilla::ErrorResult& aError);
   void SetMozCurrentTransform(JSContext* aCx,
                               JS::Handle<JSObject*> aCurrentTransform,
                               mozilla::ErrorResult& aError);
   void GetMozCurrentTransformInverse(JSContext* aCx,
@@ -362,39 +373,39 @@ public:
                                      mozilla::ErrorResult& aError);
   void SetMozCurrentTransformInverse(JSContext* aCx,
                                      JS::Handle<JSObject*> aCurrentTransform,
                                      mozilla::ErrorResult& aError);
   void GetFillRule(nsAString& aFillRule);
   void SetFillRule(const nsAString& aFillRule);
 
   void SetLineDash(const Sequence<double>& aSegments,
-                   mozilla::ErrorResult& aRv);
-  void GetLineDash(nsTArray<double>& aSegments) const;
+                   mozilla::ErrorResult& aRv) override;
+  void GetLineDash(nsTArray<double>& aSegments) const override;
 
-  void SetLineDashOffset(double aOffset);
-  double LineDashOffset() const;
+  void SetLineDashOffset(double aOffset) override;
+  double LineDashOffset() const override;
 
   void GetMozTextStyle(nsAString& aMozTextStyle)
   {
     GetFont(aMozTextStyle);
   }
 
   void SetMozTextStyle(const nsAString& aMozTextStyle,
                        mozilla::ErrorResult& aError)
   {
     SetFont(aMozTextStyle, aError);
   }
 
-  bool ImageSmoothingEnabled()
+  bool ImageSmoothingEnabled() override
   {
     return CurrentState().imageSmoothingEnabled;
   }
 
-  void SetImageSmoothingEnabled(bool aImageSmoothingEnabled)
+  void SetImageSmoothingEnabled(bool aImageSmoothingEnabled) override
   {
     if (aImageSmoothingEnabled != CurrentState().imageSmoothingEnabled) {
       CurrentState().imageSmoothingEnabled = aImageSmoothingEnabled;
     }
   }
 
   void DrawWindow(nsGlobalWindow& aWindow, double aX, double aY,
 		  double aW, double aH,

--- a/dom/canvas/moz.build
+++ b/dom/canvas/moz.build
@@ -50,16 +50,17 @@ EXPORTS += [
 ]
 
 EXPORTS.mozilla.ipc += [
     'DocumentRendererChild.h',
     'DocumentRendererParent.h',
 ]
 
 EXPORTS.mozilla.dom += [
+    'BasicRenderingContext2D.h',
     'CanvasGradient.h',
     'CanvasPath.h',
     'CanvasPattern.h',
     'CanvasRenderingContext2D.h',
     'CanvasRenderingContextHelper.h',
     'CanvasUtils.h',
     'ImageBitmap.h',
     'ImageBitmapRenderingContext.h',

--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -6666,41 +6666,38 @@ private:
  * ObjectStoreAddOrPutRequestOp::StoredFileInfo for a queued or active add/put
  * op is holding a reference to us.
  */
 class DatabaseFile final
   : public PBackgroundIDBDatabaseFileParent
 {
   friend class Database;
 
+  // mBlobImpl's ownership lifecycle:
+  // - Initialized on the background thread at creation time.  Then
+  //   responsibility is handed off to the connection thread.
+  // - Checked and used by the connection thread to generate a stream to write
+  //   the blob to disk by an add/put operation.
+  // - Cleared on the connection thread once the file has successfully been
+  //   written to disk.
   RefPtr<BlobImpl> mBlobImpl;
   RefPtr<FileInfo> mFileInfo;
 
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(mozilla::dom::indexedDB::DatabaseFile);
 
   FileInfo*
   GetFileInfo() const
   {
     AssertIsOnBackgroundThread();
 
     return mFileInfo;
   }
 
   /**
-   * Is there a blob available to provide an input stream?  This may be called
-   * on any thread under current lifecycle constraints.
-   */
-  bool
-  HasBlobImpl() const
-  {
-    return (bool)mBlobImpl;
-  }
-
-  /**
    * If mBlobImpl is non-null (implying the contents of this file have not yet
    * been written to disk), then return an input stream that is guaranteed to
    * block on reads and never return NS_BASE_STREAM_WOULD_BLOCK.  If mBlobImpl
    * is null (because the contents have been written to disk), returns null.
    *
    * Because this method does I/O, it should only be called on a database I/O
    * thread, not on PBackground.  Note that we actually open the stream on this
    * thread, where previously it was opened on PBackground.  This is safe and
@@ -6729,20 +6726,27 @@ public:
    *   writing), they will be sent up from the child via PSendStream in chunks
    *   to a non-blocking pipe that will return NS_BASE_STREAM_WOULD_BLOCK.
    * - Other Blob types could potentially be non-blocking.  (We're not making
    *   any assumptions.)
    */
   already_AddRefed<nsIInputStream>
   GetBlockingInputStream(ErrorResult &rv) const;
 
-  void
-  ClearInputStream()
-  {
-    AssertIsOnBackgroundThread();
+  /**
+   * To be called upon successful copying of the stream GetBlockingInputStream()
+   * returned so that we won't try and redundantly write the file to disk in the
+   * future.  This is a separate step from GetBlockingInputStream() because
+   * the write could fail due to quota errors that happen now but that might
+   * not happen in a future attempt.
+   */
+  void
+  WriteSucceededClearBlobImpl()
+  {
+    MOZ_ASSERT(!IsOnBackgroundThread());
 
     mBlobImpl = nullptr;
   }
 
 private:
   // Called when sending to the child.
   explicit DatabaseFile(FileInfo* aFileInfo)
     : mFileInfo(aFileInfo)
@@ -6768,18 +6772,18 @@ private:
   {
     AssertIsOnBackgroundThread();
   }
 };
 
 already_AddRefed<nsIInputStream>
 DatabaseFile::GetBlockingInputStream(ErrorResult &rv) const
 {
-  // We should only be called from a database I/O thread, not the background
-  // thread.  The background thread should call HasBlobImpl().
+  // We should only be called from our DB connection thread, not the background
+  // thread.
   MOZ_ASSERT(!IsOnBackgroundThread());
 
   if (!mBlobImpl) {
     return nullptr;
   }
 
   nsCOMPtr<nsIInputStream> inputStream;
   mBlobImpl->GetInternalStream(getter_AddRefs(inputStream), rv);
@@ -8315,18 +8319,16 @@ class ObjectStoreAddOrPutRequestOp final
   Maybe<UniqueIndexTable> mUniqueIndexTable;
 
   // This must be non-const so that we can update the mNextAutoIncrementId field
   // if we are modifying an autoIncrement objectStore.
   RefPtr<FullObjectStoreMetadata> mMetadata;
 
   FallibleTArray<StoredFileInfo> mStoredFileInfos;
 
-  RefPtr<FileManager> mFileManager;
-
   Key mResponse;
   const nsCString mGroup;
   const nsCString mOrigin;
   const PersistenceType mPersistenceType;
   const bool mOverwrite;
   bool mObjectStoreMayHaveIndexes;
   bool mDataOverThreshold;
 
@@ -8356,21 +8358,19 @@ private:
 struct ObjectStoreAddOrPutRequestOp::StoredFileInfo final
 {
   RefPtr<DatabaseFile> mFileActor;
   RefPtr<FileInfo> mFileInfo;
   // A non-Blob-backed inputstream to write to disk.  If null, mFileActor may
   // still have a stream for us to write.
   nsCOMPtr<nsIInputStream> mInputStream;
   StructuredCloneFile::FileType mType;
-  bool mCopiedSuccessfully;
 
   StoredFileInfo()
     : mType(StructuredCloneFile::eBlob)
-    , mCopiedSuccessfully(false)
   {
     AssertIsOnBackgroundThread();
 
     MOZ_COUNT_CTOR(ObjectStoreAddOrPutRequestOp::StoredFileInfo);
   }
 
   ~StoredFileInfo()
   {
@@ -26150,20 +26150,16 @@ ObjectStoreAddOrPutRequestOp::Init(Trans
 
   if (!fileAddInfos.IsEmpty()) {
     const uint32_t count = fileAddInfos.Length();
 
     if (NS_WARN_IF(!mStoredFileInfos.SetCapacity(count, fallible))) {
       return false;
     }
 
-    RefPtr<FileManager> fileManager =
-      aTransaction->GetDatabase()->GetFileManager();
-    MOZ_ASSERT(fileManager);
-
     for (uint32_t index = 0; index < count; index++) {
       const FileAddInfo& fileAddInfo = fileAddInfos[index];
 
       MOZ_ASSERT(fileAddInfo.type() == StructuredCloneFile::eBlob ||
                  fileAddInfo.type() == StructuredCloneFile::eMutableFile ||
                  fileAddInfo.type() == StructuredCloneFile::eWasmBytecode ||
                  fileAddInfo.type() == StructuredCloneFile::eWasmCompiled);
 
@@ -26180,20 +26176,16 @@ ObjectStoreAddOrPutRequestOp::Init(Trans
           storedFileInfo->mFileActor =
             static_cast<DatabaseFile*>(
               file.get_PBackgroundIDBDatabaseFileParent());
           MOZ_ASSERT(storedFileInfo->mFileActor);
 
           storedFileInfo->mFileInfo = storedFileInfo->mFileActor->GetFileInfo();
           MOZ_ASSERT(storedFileInfo->mFileInfo);
 
-          if (storedFileInfo->mFileActor->HasBlobImpl() && !mFileManager) {
-            mFileManager = fileManager;
-          }
-
           storedFileInfo->mType = StructuredCloneFile::eBlob;
           break;
         }
 
         case StructuredCloneFile::eMutableFile: {
           MOZ_ASSERT(file.type() ==
                        DatabaseOrMutableFile::TPBackgroundMutableFileParent);
 
@@ -26217,57 +26209,51 @@ ObjectStoreAddOrPutRequestOp::Init(Trans
           storedFileInfo->mFileActor =
             static_cast<DatabaseFile*>(
               file.get_PBackgroundIDBDatabaseFileParent());
           MOZ_ASSERT(storedFileInfo->mFileActor);
 
           storedFileInfo->mFileInfo = storedFileInfo->mFileActor->GetFileInfo();
           MOZ_ASSERT(storedFileInfo->mFileInfo);
 
-          if (storedFileInfo->mFileActor->HasBlobImpl() && !mFileManager) {
-            mFileManager = fileManager;
-          }
-
           storedFileInfo->mType = fileAddInfo.type();
           break;
         }
 
         default:
           MOZ_CRASH("Should never get here!");
       }
     }
   }
 
   if (mDataOverThreshold) {
     StoredFileInfo* storedFileInfo = mStoredFileInfos.AppendElement(fallible);
     MOZ_ASSERT(storedFileInfo);
 
-    if (!mFileManager) {
-      mFileManager = aTransaction->GetDatabase()->GetFileManager();
-      MOZ_ASSERT(mFileManager);
-    }
-
-    storedFileInfo->mFileInfo = mFileManager->GetNewFileInfo();
+    RefPtr<FileManager> fileManager =
+      aTransaction->GetDatabase()->GetFileManager();
+    MOZ_ASSERT(fileManager);
+
+    storedFileInfo->mFileInfo = fileManager->GetNewFileInfo();
 
     storedFileInfo->mInputStream =
       new SCInputStream(mParams.cloneInfo().data().data);
 
     storedFileInfo->mType = StructuredCloneFile::eStructuredClone;
   }
 
   return true;
 }
 
 nsresult
 ObjectStoreAddOrPutRequestOp::DoDatabaseWork(DatabaseConnection* aConnection)
 {
   MOZ_ASSERT(aConnection);
   aConnection->AssertIsOnConnectionThread();
   MOZ_ASSERT(aConnection->GetStorageConnection());
-  MOZ_ASSERT_IF(mFileManager, !mStoredFileInfos.IsEmpty());
 
   PROFILER_LABEL("IndexedDB",
                  "ObjectStoreAddOrPutRequestOp::DoDatabaseWork",
                  js::ProfileEntry::Category::STORAGE);
 
   if (NS_WARN_IF(IndexedDatabaseManager::InLowDiskSpaceMode())) {
     return NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR;
   }
@@ -26434,44 +26420,34 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
 
     rv = stmt->BindAdoptedBlobByName(NS_LITERAL_CSTRING("data"), dataBuffer,
                                      dataBufferLength);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
-  Maybe<FileHelper> fileHelper;
-
-  if (mFileManager) {
-    fileHelper.emplace(mFileManager);
-
-    rv = fileHelper->Init();
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      IDB_REPORT_INTERNAL_ERR();
-      return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
-    }
-  }
-
   if (!mStoredFileInfos.IsEmpty()) {
+    // Moved outside the loop to allow it to be cached when demanded by the
+    // first write.  (We may have mStoredFileInfos without any required writes.)
+    Maybe<FileHelper> fileHelper;
     nsAutoString fileIds;
 
     for (uint32_t count = mStoredFileInfos.Length(), index = 0;
          index < count;
          index++) {
       StoredFileInfo& storedFileInfo = mStoredFileInfos[index];
       MOZ_ASSERT(storedFileInfo.mFileInfo);
 
       // If there is a StoredFileInfo, then one of the following is true:
       // - This was an overflow structured clone and storedFileInfo.mInputStream
       //   MUST be non-null.
       // - This is a reference to a Blob that may or may not have already been
       //   written to disk.  storedFileInfo.mFileActor MUST be non-null, but
-      //   its HasBlobImpl() may return false and so GetBlockingInputStream may
-      //   return null (so don't assert on them).
+      //   its GetBlockingInputStream may return null (so don't assert on them).
       // - It's a mutable file.  No writing will be performed.
       MOZ_ASSERT(storedFileInfo.mInputStream || storedFileInfo.mFileActor ||
                  storedFileInfo.mType == StructuredCloneFile::eMutableFile);
 
       nsCOMPtr<nsIInputStream> inputStream;
       // Check for an explicit stream, like a structured clone stream.
       storedFileInfo.mInputStream.swap(inputStream);
       // Check for a blob-backed stream otherwise.
@@ -26480,16 +26456,29 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
         inputStream =
           storedFileInfo.mFileActor->GetBlockingInputStream(streamRv);
         if (NS_WARN_IF(streamRv.Failed())) {
           return streamRv.StealNSResult();
         }
       }
 
       if (inputStream) {
+        if (fileHelper.isNothing()) {
+          RefPtr<FileManager> fileManager =
+            Transaction()->GetDatabase()->GetFileManager();
+          MOZ_ASSERT(fileManager);
+
+          fileHelper.emplace(fileManager);
+          rv = fileHelper->Init();
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            IDB_REPORT_INTERNAL_ERR();
+            return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
+          }
+        }
+
         RefPtr<FileInfo>& fileInfo = storedFileInfo.mFileInfo;
 
         nsCOMPtr<nsIFile> file = fileHelper->GetFile(fileInfo);
         if (NS_WARN_IF(!file)) {
           IDB_REPORT_INTERNAL_ERR();
           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
         }
 
@@ -26516,17 +26505,19 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
           // Try to remove the file if the copy failed.
           nsresult rv2 = fileHelper->RemoveFile(file, journalFile);
           if (NS_WARN_IF(NS_FAILED(rv2))) {
             return rv;
           }
           return rv;
         }
 
-        storedFileInfo.mCopiedSuccessfully = true;
+        if (storedFileInfo.mFileActor) {
+          storedFileInfo.mFileActor->WriteSucceededClearBlobImpl();
+        }
       }
 
       if (index) {
         fileIds.Append(' ');
       }
       storedFileInfo.Serialize(fileIds);
     }
 
@@ -26600,33 +26591,17 @@ ObjectStoreAddOrPutRequestOp::GetRespons
   }
 }
 
 void
 ObjectStoreAddOrPutRequestOp::Cleanup()
 {
   AssertIsOnOwningThread();
 
-  if (!mStoredFileInfos.IsEmpty()) {
-    for (uint32_t count = mStoredFileInfos.Length(), index = 0;
-         index < count;
-         index++) {
-      StoredFileInfo& storedFileInfo = mStoredFileInfos[index];
-
-      MOZ_ASSERT_IF(storedFileInfo.mType == StructuredCloneFile::eMutableFile,
-                    !storedFileInfo.mCopiedSuccessfully);
-
-      RefPtr<DatabaseFile>& fileActor = storedFileInfo.mFileActor;
-      if (fileActor && storedFileInfo.mCopiedSuccessfully) {
-        fileActor->ClearInputStream();
-      }
-    }
-
-    mStoredFileInfos.Clear();
-  }
+  mStoredFileInfos.Clear();
 
   NormalTransactionOp::Cleanup();
 }
 
 NS_IMPL_ISUPPORTS(ObjectStoreAddOrPutRequestOp::SCInputStream, nsIInputStream)
 
 NS_IMETHODIMP
 ObjectStoreAddOrPutRequestOp::

--- a/dom/locales/en-US/chrome/dom/dom.properties
+++ b/dom/locales/en-US/chrome/dom/dom.properties
@@ -316,8 +316,10 @@ LargeAllocationSuccess=This page was loa
 LargeAllocationNonGetRequest=A Large-Allocation header was ignored due to the load being triggered by a non-GET request.
 # LOCALIZATION NOTE: Do not translate "Large-Allocation", as it is a literal header name. Do not translate `window.opener`.
 LargeAllocationNotOnlyToplevelInTabGroup=A Large-Allocation header was ignored due to the presence of windows which have a reference to this browsing context through the frame hierarchy or window.opener.
 # LOCALIZATION NOTE: Do not translate "Large-Allocation", as it is a literal header name
 LargeAllocationNonE10S=A Large-Allocation header was ignored due to the document not being loaded out of process.
 GeolocationInsecureRequestIsForbidden=A Geolocation request can only be fulfilled in a secure context.
 # LOCALIZATION NOTE: Do not translate "Large-Allocation", as it is a literal header name.
 LargeAllocationNonWin32=This page would be loaded in a new process due to a Large-Allocation header, however Large-Allocation process creation is disabled on non-Win32 platforms.
+# LOCALIZATION NOTE: Do not translate URL.createObjectURL(MediaStream).
+URLCreateObjectURL_MediaStream=URL.createObjectURL(MediaStream) is deprecated and will be removed soon.

--- a/dom/media/platforms/wmf/WMF.h
+++ b/dom/media/platforms/wmf/WMF.h
@@ -2,45 +2,33 @@
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* 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/. */
 
 #ifndef WMF_H_
 #define WMF_H_
 
-#if WINVER < _WIN32_WINNT_WIN7
-#error \
-You must include WMF.h before including mozilla headers, \
-otherwise mozconfig.h will be included \
-and that sets WINVER to WinXP, \
-which makes Windows Media Foundation unavailable.
-#endif
-
-#pragma push_macro("WINVER")
-#undef WINVER
-#define WINVER _WIN32_WINNT_WIN7
-
 #include <windows.h>
 #include <mfapi.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <mfobjects.h>
 #include <ks.h>
 #include <stdio.h>
 #include <mferror.h>
 #include <propvarutil.h>
 #include <wmcodecdsp.h>
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <wmcodecdsp.h>
 #include <codecapi.h>
 
 // The Windows headers helpfully declare min and max macros, which don't
-// compile in the prescence of std::min and std::max and unified builds.
+// compile in the presence of std::min and std::max and unified builds.
 // So undef them here.
 #ifdef min
 #undef min
 #endif
 #ifdef max
 #undef max
 #endif
 
@@ -92,13 +80,9 @@ HRESULT MFCreateDXGISurfaceBuffer(REFIID
                                   IUnknown *punkSurface,
                                   UINT uSubresourceIndex,
                                   BOOL fButtomUpWhenLinear,
                                   IMFMediaBuffer **ppBuffer);
 
 } // end namespace wmf
 } // end namespace mozilla
 
-
-
-#pragma pop_macro("WINVER")
-
 #endif

--- a/dom/url/URL.cpp
+++ b/dom/url/URL.cpp
@@ -1722,16 +1722,19 @@ URL::CreateObjectURL(const GlobalObject&
   }
 }
 
 void
 URL::CreateObjectURL(const GlobalObject& aGlobal, DOMMediaStream& aStream,
                      nsAString& aResult, ErrorResult& aRv)
 {
   MOZ_ASSERT(NS_IsMainThread());
+
+  DeprecationWarning(aGlobal, nsIDocument::eURLCreateObjectURL_MediaStream);
+
   URLMainThread::CreateObjectURL(aGlobal, aStream, aResult, aRv);
 }
 
 void
 URL::CreateObjectURL(const GlobalObject& aGlobal, MediaSource& aSource,
                      nsAString& aResult, ErrorResult& aRv)
 {
   MOZ_ASSERT(NS_IsMainThread());

--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -867,27 +867,19 @@ private:
   nsresult
   LoadScript(uint32_t aIndex)
   {
     AssertIsOnMainThread();
     MOZ_ASSERT(aIndex < mLoadInfos.Length());
 
     WorkerPrivate* parentWorker = mWorkerPrivate->GetParent();
 
-    // Figure out which principal to use.
     nsIPrincipal* principal = mWorkerPrivate->GetPrincipal();
     nsCOMPtr<nsILoadGroup> loadGroup = mWorkerPrivate->GetLoadGroup();
-    if (!principal) {
-      NS_ASSERTION(parentWorker, "Must have a principal!");
-      NS_ASSERTION(mIsMainScript, "Must have a principal for importScripts!");
-
-      principal = parentWorker->GetPrincipal();
-      loadGroup = parentWorker->GetLoadGroup();
-    }
-    NS_ASSERTION(principal, "This should never be null here!");
+    MOZ_DIAGNOSTIC_ASSERT(principal);
     MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(loadGroup, principal));
 
     // Figure out our base URI.
     nsCOMPtr<nsIURI> baseURI = GetBaseURI(mIsMainScript, mWorkerPrivate);
 
     // May be null.
     nsCOMPtr<nsIDocument> parentDoc = mWorkerPrivate->GetDocument();
 
@@ -1132,71 +1124,17 @@ private:
     // worker's primary script.
     if (IsMainWorkerScript()) {
       // Take care of the base URI first.
       mWorkerPrivate->SetBaseURI(finalURI);
 
       // Store the channel info if needed.
       mWorkerPrivate->InitChannelInfo(channel);
 
-      // Now to figure out which principal to give this worker.
-      WorkerPrivate* parent = mWorkerPrivate->GetParent();
-
-      NS_ASSERTION(mWorkerPrivate->GetPrincipal() || parent,
-                   "Must have one of these!");
-
-      nsCOMPtr<nsIPrincipal> loadPrincipal = mWorkerPrivate->GetPrincipal() ?
-                                             mWorkerPrivate->GetPrincipal() :
-                                             parent->GetPrincipal();
-
-      nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
-      NS_ASSERTION(ssm, "Should never be null!");
-
-      nsCOMPtr<nsIPrincipal> channelPrincipal;
-      rv = ssm->GetChannelResultPrincipal(channel, getter_AddRefs(channelPrincipal));
-      NS_ENSURE_SUCCESS(rv, rv);
-
-      nsCOMPtr<nsILoadGroup> channelLoadGroup;
-      rv = channel->GetLoadGroup(getter_AddRefs(channelLoadGroup));
-      NS_ENSURE_SUCCESS(rv, rv);
-      MOZ_ASSERT(channelLoadGroup);
-
-      // If the load principal is the system principal then the channel
-      // principal must also be the system principal (we do not allow chrome
-      // code to create workers with non-chrome scripts, and if we ever decide
-      // to change this we need to make sure we don't always set
-      // mPrincipalIsSystem to true in WorkerPrivate::GetLoadInfo()). Otherwise
-      // this channel principal must be same origin with the load principal (we
-      // check again here in case redirects changed the location of the script).
-      if (nsContentUtils::IsSystemPrincipal(loadPrincipal)) {
-        if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) {
-          // See if this is a resource URI. Since JSMs usually come from
-          // resource:// URIs we're currently considering all URIs with the
-          // URI_IS_UI_RESOURCE flag as valid for creating privileged workers.
-          bool isResource;
-          rv = NS_URIChainHasFlags(finalURI,
-                                   nsIProtocolHandler::URI_IS_UI_RESOURCE,
-                                   &isResource);
-          NS_ENSURE_SUCCESS(rv, rv);
-
-          if (isResource) {
-            // Assign the system principal to the resource:// worker only if it
-            // was loaded from code using the system principal.
-            channelPrincipal = loadPrincipal;
-          } else {
-            return NS_ERROR_DOM_BAD_URI;
-          }
-        }
-      }
-
-      // The principal can change, but it should still match the original
-      // load group's appId and browser element flag.
-      MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(channelLoadGroup, channelPrincipal));
-
-      mWorkerPrivate->SetPrincipal(channelPrincipal, channelLoadGroup);
+      MOZ_DIAGNOSTIC_ASSERT(mWorkerPrivate->FinalChannelPrincipalIsValid(channel));
 
       // We did inherit CSP in bug 1223647. If we do not already have a CSP, we
       // should get it from the HTTP headers on the worker script.
       if (!mWorkerPrivate->GetCSP() && CSPService::sCSPEnabled) {
         NS_ConvertASCIItoUTF16 cspHeaderValue(tCspHeaderValue);
         NS_ConvertASCIItoUTF16 cspROHeaderValue(tCspROHeaderValue);
 
         nsIPrincipal* principal = mWorkerPrivate->GetPrincipal();
@@ -1234,16 +1172,17 @@ private:
           NS_ENSURE_SUCCESS(rv, rv);
 
 
           if (hasReferrerPolicy) { //FIXME bug 1307366: move RP out of CSP code
             mWorkerPrivate->SetReferrerPolicy(static_cast<net::ReferrerPolicy>(rp));
           }
         }
       }
+      WorkerPrivate* parent = mWorkerPrivate->GetParent();
       if (parent) {
         // XHR Params Allowed
         mWorkerPrivate->SetXHRParamsAllowed(parent->XHRParamsAllowed());
       }
     }
 
     NS_ConvertUTF8toUTF16 tRPHeaderValue(tRPHeaderCValue);
     // If there's a Referrer-Policy header, apply it.
@@ -1303,17 +1242,17 @@ private:
       nsILoadGroup* loadGroup = mWorkerPrivate->GetLoadGroup();
       MOZ_ASSERT(loadGroup);
 
       mozilla::DebugOnly<bool> equal = false;
       MOZ_ASSERT(responsePrincipal && NS_SUCCEEDED(responsePrincipal->Equals(principal, &equal)));
       MOZ_ASSERT(equal);
 
       mWorkerPrivate->InitChannelInfo(aChannelInfo);
-      mWorkerPrivate->SetPrincipal(responsePrincipal, loadGroup);
+      mWorkerPrivate->SetPrincipalOnMainThread(responsePrincipal, loadGroup);
     }
 
     if (NS_SUCCEEDED(rv)) {
       DataReceived();
     }
 
     LoadingFinished(aIndex, rv);
   }
@@ -1790,64 +1729,71 @@ CacheScriptLoader::OnStreamComplete(nsIS
   mRunnable->DataReceivedFromCache(mIndex, aString, aStringLen, mChannelInfo,
                                    Move(mPrincipalInfo));
   return NS_OK;
 }
 
 class ChannelGetterRunnable final : public WorkerMainThreadRunnable
 {
   const nsAString& mScriptURL;
-  nsIChannel** mChannel;
+  WorkerLoadInfo& mLoadInfo;
   nsresult mResult;
 
 public:
   ChannelGetterRunnable(WorkerPrivate* aParentWorker,
                         const nsAString& aScriptURL,
-                        nsIChannel** aChannel)
+                        WorkerLoadInfo& aLoadInfo)
     : WorkerMainThreadRunnable(aParentWorker,
                                NS_LITERAL_CSTRING("ScriptLoader :: ChannelGetter"))
     , mScriptURL(aScriptURL)
-    , mChannel(aChannel)
+    , mLoadInfo(aLoadInfo)
     , mResult(NS_ERROR_FAILURE)
   {
     MOZ_ASSERT(aParentWorker);
     aParentWorker->AssertIsOnWorkerThread();
   }
 
   virtual bool
   MainThreadRun() override
   {
     AssertIsOnMainThread();
 
-    nsIPrincipal* principal = mWorkerPrivate->GetPrincipal();
-    MOZ_ASSERT(principal);
+    // Initialize the WorkerLoadInfo principal to our triggering principal
+    // before doing anything else.  Normally we do this in the WorkerPrivate
+    // Constructor, but we can't do so off the main thread when creating
+    // a nested worker.  So do it here instead.
+    mLoadInfo.mPrincipal = mWorkerPrivate->GetPrincipal();
+    MOZ_ASSERT(mLoadInfo.mPrincipal);
 
     // Figure out our base URI.
     nsCOMPtr<nsIURI> baseURI = mWorkerPrivate->GetBaseURI();
     MOZ_ASSERT(baseURI);
 
     // May be null.
     nsCOMPtr<nsIDocument> parentDoc = mWorkerPrivate->GetDocument();
 
-    nsCOMPtr<nsILoadGroup> loadGroup = mWorkerPrivate->GetLoadGroup();
+    mLoadInfo.mLoadGroup = mWorkerPrivate->GetLoadGroup();
 
     nsCOMPtr<nsIChannel> channel;
     mResult =
-      scriptloader::ChannelFromScriptURLMainThread(principal, baseURI,
-                                                   parentDoc, loadGroup,
+      scriptloader::ChannelFromScriptURLMainThread(mLoadInfo.mPrincipal,
+                                                   baseURI, parentDoc,
+                                                   mLoadInfo.mLoadGroup,
                                                    mScriptURL,
                                                    // Nested workers are always dedicated.
                                                    nsIContentPolicy::TYPE_INTERNAL_WORKER,
                                                    // Nested workers use default uri encoding.
                                                    true,
                                                    getter_AddRefs(channel));
-    if (NS_SUCCEEDED(mResult)) {
-      channel.forget(mChannel);
-    }
+    NS_ENSURE_SUCCESS(mResult, true);
 
+    mResult = mLoadInfo.SetPrincipalFromChannel(channel);
+    NS_ENSURE_SUCCESS(mResult, true);
+
+    mLoadInfo.mChannel = channel.forget();
     return true;
   }
 
   nsresult
   GetResult() const
   {
     return mResult;
   }
@@ -2173,22 +2119,22 @@ ChannelFromScriptURLMainThread(nsIPrinci
                               aContentPolicyType, nsIRequest::LOAD_NORMAL,
                               aDefaultURIEncoding, aChannel);
 }
 
 nsresult
 ChannelFromScriptURLWorkerThread(JSContext* aCx,
                                  WorkerPrivate* aParent,
                                  const nsAString& aScriptURL,
-                                 nsIChannel** aChannel)
+                                 WorkerLoadInfo& aLoadInfo)
 {
   aParent->AssertIsOnWorkerThread();
 
   RefPtr<ChannelGetterRunnable> getter =
-    new ChannelGetterRunnable(aParent, aScriptURL, aChannel);
+    new ChannelGetterRunnable(aParent, aScriptURL, aLoadInfo);
 
   ErrorResult rv;
   getter->Dispatch(Terminating, rv);
   if (rv.Failed()) {
     NS_ERROR("Failed to dispatch!");
     return rv.StealNSResult();
   }
 

--- a/dom/workers/ScriptLoader.h
+++ b/dom/workers/ScriptLoader.h
@@ -41,17 +41,17 @@ ChannelFromScriptURLMainThread(nsIPrinci
                                nsContentPolicyType aContentPolicyType,
                                bool aDefaultURIEncoding,
                                nsIChannel** aChannel);
 
 nsresult
 ChannelFromScriptURLWorkerThread(JSContext* aCx,
                                  WorkerPrivate* aParent,
                                  const nsAString& aScriptURL,
-                                 nsIChannel** aChannel);
+                                 WorkerLoadInfo& aLoadInfo);
 
 void ReportLoadError(ErrorResult& aRv, nsresult aLoadResult,
                      const nsAString& aScriptURL);
 
 void LoadMainScript(WorkerPrivate* aWorkerPrivate,
                     const nsAString& aScriptURL,
                     WorkerScriptType aWorkerScriptType,
                     ErrorResult& aRv);

--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -390,25 +390,17 @@ private:
   PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override
   {
     // Silence bad assertions.
   }
 
   virtual bool
   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
   {
-    nsCOMPtr<nsILoadGroup> loadGroupToCancel;
-    mFinishedWorker->ForgetOverridenLoadGroup(loadGroupToCancel);
-
-    nsTArray<nsCOMPtr<nsISupports>> doomed;
-    mFinishedWorker->ForgetMainThreadObjects(doomed);
-
-    RefPtr<MainThreadReleaseRunnable> runnable =
-      new MainThreadReleaseRunnable(doomed, loadGroupToCancel);
-    if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable.forget()))) {
+    if (!mFinishedWorker->ProxyReleaseMainThreadObjects()) {
       NS_WARNING("Failed to dispatch, going to leak!");
     }
 
     RuntimeService* runtime = RuntimeService::GetService();
     NS_ASSERTION(runtime, "This should never be null!");
 
     mFinishedWorker->DisableDebugger();
 
@@ -442,25 +434,17 @@ private:
 
     RuntimeService* runtime = RuntimeService::GetService();
     MOZ_ASSERT(runtime);
 
     mFinishedWorker->DisableDebugger();
 
     runtime->UnregisterWorker(mFinishedWorker);
 
-    nsCOMPtr<nsILoadGroup> loadGroupToCancel;
-    mFinishedWorker->ForgetOverridenLoadGroup(loadGroupToCancel);
-
-    nsTArray<nsCOMPtr<nsISupports> > doomed;
-    mFinishedWorker->ForgetMainThreadObjects(doomed);
-
-    RefPtr<MainThreadReleaseRunnable> runnable =
-      new MainThreadReleaseRunnable(doomed, loadGroupToCancel);
-    if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
+    if (!mFinishedWorker->ProxyReleaseMainThreadObjects()) {
       NS_WARNING("Failed to dispatch, going to leak!");
     }
 
     mFinishedWorker->ClearSelfRef();
     return NS_OK;
   }
 };
 
@@ -1846,16 +1830,203 @@ WorkerLoadInfo::StealFrom(WorkerLoadInfo
   mReportCSPViolations = aOther.mReportCSPViolations;
   mXHRParamsAllowed = aOther.mXHRParamsAllowed;
   mPrincipalIsSystem = aOther.mPrincipalIsSystem;
   mStorageAllowed = aOther.mStorageAllowed;
   mServiceWorkersTestingInWindow = aOther.mServiceWorkersTestingInWindow;
   mOriginAttributes = aOther.mOriginAttributes;
 }
 
+void
+WorkerLoadInfo::SetPrincipalOnMainThread(nsIPrincipal* aPrincipal,
+                                         nsILoadGroup* aLoadGroup)
+{
+  AssertIsOnMainThread();
+  MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(aLoadGroup, aPrincipal));
+  MOZ_ASSERT(!mPrincipalInfo);
+
+  mPrincipal = aPrincipal;
+  mPrincipalIsSystem = nsContentUtils::IsSystemPrincipal(aPrincipal);
+
+  aPrincipal->GetCsp(getter_AddRefs(mCSP));
+
+  if (mCSP) {
+    mCSP->GetAllowsEval(&mReportCSPViolations, &mEvalAllowed);
+    // Set ReferrerPolicy
+    bool hasReferrerPolicy = false;
+    uint32_t rp = mozilla::net::RP_Unset;
+
+    nsresult rv = mCSP->GetReferrerPolicy(&rp, &hasReferrerPolicy);
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    if (hasReferrerPolicy) {
+      mReferrerPolicy = static_cast<net::ReferrerPolicy>(rp);
+    }
+  } else {
+    mEvalAllowed = true;
+    mReportCSPViolations = false;
+  }
+
+  mLoadGroup = aLoadGroup;
+
+  mPrincipalInfo = new PrincipalInfo();
+  mOriginAttributes = nsContentUtils::GetOriginAttributes(aLoadGroup);
+
+  MOZ_ALWAYS_SUCCEEDS(
+    PrincipalToPrincipalInfo(aPrincipal, mPrincipalInfo));
+}
+
+nsresult
+WorkerLoadInfo::GetPrincipalAndLoadGroupFromChannel(nsIChannel* aChannel,
+                                                    nsIPrincipal** aPrincipalOut,
+                                                    nsILoadGroup** aLoadGroupOut)
+{
+  AssertIsOnMainThread();
+  MOZ_DIAGNOSTIC_ASSERT(aChannel);
+  MOZ_DIAGNOSTIC_ASSERT(aPrincipalOut);
+  MOZ_DIAGNOSTIC_ASSERT(aLoadGroupOut);
+
+  // Initial triggering principal should be set
+  MOZ_DIAGNOSTIC_ASSERT(mPrincipal);
+
+  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+  MOZ_DIAGNOSTIC_ASSERT(ssm);
+
+  nsCOMPtr<nsIPrincipal> channelPrincipal;
+  nsresult rv = ssm->GetChannelResultPrincipal(aChannel, getter_AddRefs(channelPrincipal));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsILoadGroup> channelLoadGroup;
+  rv = aChannel->GetLoadGroup(getter_AddRefs(channelLoadGroup));
+  NS_ENSURE_SUCCESS(rv, rv);
+  MOZ_ASSERT(channelLoadGroup);
+
+  // If the load principal is the system principal then the channel
+  // principal must also be the system principal (we do not allow chrome
+  // code to create workers with non-chrome scripts, and if we ever decide
+  // to change this we need to make sure we don't always set
+  // mPrincipalIsSystem to true in WorkerPrivate::GetLoadInfo()). Otherwise
+  // this channel principal must be same origin with the load principal (we
+  // check again here in case redirects changed the location of the script).
+  if (nsContentUtils::IsSystemPrincipal(mPrincipal)) {
+    if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) {
+      nsCOMPtr<nsIURI> finalURI;
+      rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(finalURI));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // See if this is a resource URI. Since JSMs usually come from
+      // resource:// URIs we're currently considering all URIs with the
+      // URI_IS_UI_RESOURCE flag as valid for creating privileged workers.
+      bool isResource;
+      rv = NS_URIChainHasFlags(finalURI,
+                               nsIProtocolHandler::URI_IS_UI_RESOURCE,
+                               &isResource);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (isResource) {
+        // Assign the system principal to the resource:// worker only if it
+        // was loaded from code using the system principal.
+        channelPrincipal = mPrincipal;
+      } else {
+        return NS_ERROR_DOM_BAD_URI;
+      }
+    }
+  }
+
+  // The principal can change, but it should still match the original
+  // load group's appId and browser element flag.
+  MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(channelLoadGroup, channelPrincipal));
+
+  channelPrincipal.forget(aPrincipalOut);
+  channelLoadGroup.forget(aLoadGroupOut);
+
+  return NS_OK;
+}
+
+nsresult
+WorkerLoadInfo::SetPrincipalFromChannel(nsIChannel* aChannel)
+{
+  AssertIsOnMainThread();
+
+  nsCOMPtr<nsIPrincipal> principal;
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  nsresult rv = GetPrincipalAndLoadGroupFromChannel(aChannel,
+                                                    getter_AddRefs(principal),
+                                                    getter_AddRefs(loadGroup));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  SetPrincipalOnMainThread(principal, loadGroup);
+  return NS_OK;
+}
+
+#if defined(DEBUG) || !defined(RELEASE_OR_BETA)
+bool
+WorkerLoadInfo::FinalChannelPrincipalIsValid(nsIChannel* aChannel)
+{
+  AssertIsOnMainThread();
+
+  nsCOMPtr<nsIPrincipal> principal;
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  nsresult rv = GetPrincipalAndLoadGroupFromChannel(aChannel,
+                                                    getter_AddRefs(principal),
+                                                    getter_AddRefs(loadGroup));
+  NS_ENSURE_SUCCESS(rv, false);
+
+
+  // Verify that the channel is still a null principal.  We don't care
+  // if these are the exact same null principal object, though.  From
+  // the worker's perspective its the same effect.
+  if (principal->GetIsNullPrincipal() && mPrincipal->GetIsNullPrincipal()) {
+    return true;
+  }
+
+  // Otherwise we require exact equality.  Redirects can happen, but they
+  // are not allowed to change our principal.
+  if (principal->Equals(mPrincipal)) {
+    return true;
+  }
+
+  return false;
+}
+#endif // defined(DEBUG) || !defined(RELEASE_OR_BETA)
+
+bool
+WorkerLoadInfo::ProxyReleaseMainThreadObjects(WorkerPrivate* aWorkerPrivate)
+{
+  nsCOMPtr<nsILoadGroup> nullLoadGroup;
+  return ProxyReleaseMainThreadObjects(aWorkerPrivate, nullLoadGroup);
+}
+
+bool
+WorkerLoadInfo::ProxyReleaseMainThreadObjects(WorkerPrivate* aWorkerPrivate,
+                                              nsCOMPtr<nsILoadGroup>& aLoadGroupToCancel)
+{
+
+  static const uint32_t kDoomedCount = 10;
+  nsTArray<nsCOMPtr<nsISupports>> doomed(kDoomedCount);
+
+  SwapToISupportsArray(mWindow, doomed);
+  SwapToISupportsArray(mScriptContext, doomed);
+  SwapToISupportsArray(mBaseURI, doomed);
+  SwapToISupportsArray(mResolvedScriptURI, doomed);
+  SwapToISupportsArray(mPrincipal, doomed);
+  SwapToISupportsArray(mChannel, doomed);
+  SwapToISupportsArray(mCSP, doomed);
+  SwapToISupportsArray(mLoadGroup, doomed);
+  SwapToISupportsArray(mLoadFailedAsyncRunnable, doomed);
+  SwapToISupportsArray(mInterfaceRequestor, doomed);
+  // Before adding anything here update kDoomedCount above!
+
+  MOZ_ASSERT(doomed.Length() == kDoomedCount);
+
+  RefPtr<MainThreadReleaseRunnable> runnable =
+    new MainThreadReleaseRunnable(doomed, aLoadGroupToCancel);
+  return NS_SUCCEEDED(aWorkerPrivate->DispatchToMainThread(runnable.forget()));
+}
+
 template <class Derived>
 class WorkerPrivateParent<Derived>::EventTarget final
   : public nsIEventTarget
 {
   // This mutex protects mWorkerPrivate and must be acquired *before* the
   // WorkerPrivate's mutex whenever they must both be held.
   mozilla::Mutex mMutex;
   WorkerPrivate* mWorkerPrivate;
@@ -3026,58 +3197,35 @@ WorkerPrivateParent<Derived>::ModifyBusy
       return false;
     }
   }
 
   return true;
 }
 
 template <class Derived>
-void
-WorkerPrivateParent<Derived>::ForgetOverridenLoadGroup(
-                                          nsCOMPtr<nsILoadGroup>& aLoadGroupOut)
-{
-  AssertIsOnParentThread();
-
-  // If we're not overriden, then do nothing here.  Let the load group get
-  // handled in ForgetMainThreadObjects().
-  if (!mLoadInfo.mInterfaceRequestor) {
-    return;
-  }
-
-  mLoadInfo.mLoadGroup.swap(aLoadGroupOut);
-}
-
-template <class Derived>
-void
-WorkerPrivateParent<Derived>::ForgetMainThreadObjects(
-                                      nsTArray<nsCOMPtr<nsISupports> >& aDoomed)
+bool
+WorkerPrivateParent<Derived>::ProxyReleaseMainThreadObjects()
 {
   AssertIsOnParentThread();
   MOZ_ASSERT(!mMainThreadObjectsForgotten);
 
-  static const uint32_t kDoomedCount = 10;
-
-  aDoomed.SetCapacity(kDoomedCount);
-
-  SwapToISupportsArray(mLoadInfo.mWindow, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mScriptContext, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mBaseURI, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mResolvedScriptURI, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mPrincipal, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mChannel, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mCSP, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mLoadGroup, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mLoadFailedAsyncRunnable, aDoomed);
-  SwapToISupportsArray(mLoadInfo.mInterfaceRequestor, aDoomed);
-  // Before adding anything here update kDoomedCount above!
-
-  MOZ_ASSERT(aDoomed.Length() == kDoomedCount);
+  nsCOMPtr<nsILoadGroup> loadGroupToCancel;
+  // If we're not overriden, then do nothing here.  Let the load group get
+  // handled in ForgetMainThreadObjects().
+  if (mLoadInfo.mInterfaceRequestor) {
+    mLoadInfo.mLoadGroup.swap(loadGroupToCancel);
+  }
+
+  bool result = mLoadInfo.ProxyReleaseMainThreadObjects(ParentAsWorkerPrivate(),
+                                                        loadGroupToCancel);
 
   mMainThreadObjectsForgotten = true;
+
+  return result;
 }
 
 template <class Derived>
 void
 WorkerPrivateParent<Derived>::PostMessageInternal(JSContext* aCx,
                                                   JS::Handle<JS::Value> aMessage,
                                                   const Sequence<JSObject*>& aTransferable,
                                                   ErrorResult& aRv)
@@ -3651,54 +3799,37 @@ WorkerPrivateParent<Derived>::SetBaseURI
     mLocationInfo.mHost.Assign(mLocationInfo.mHostname);
   }
 
   nsContentUtils::GetUTFOrigin(aBaseURI, mLocationInfo.mOrigin);
 }
 
 template <class Derived>
 void
-WorkerPrivateParent<Derived>::SetPrincipal(nsIPrincipal* aPrincipal,
-                                           nsILoadGroup* aLoadGroup)
-{
-  AssertIsOnMainThread();
-  MOZ_ASSERT(NS_LoadGroupMatchesPrincipal(aLoadGroup, aPrincipal));
-  MOZ_ASSERT(!mLoadInfo.mPrincipalInfo);
-
-  mLoadInfo.mPrincipal = aPrincipal;
-  mLoadInfo.mPrincipalIsSystem = nsContentUtils::IsSystemPrincipal(aPrincipal);
-
-  aPrincipal->GetCsp(getter_AddRefs(mLoadInfo.mCSP));
-
-  if (mLoadInfo.mCSP) {
-    mLoadInfo.mCSP->GetAllowsEval(&mLoadInfo.mReportCSPViolations,
-                                  &mLoadInfo.mEvalAllowed);
-    // Set ReferrerPolicy
-    bool hasReferrerPolicy = false;
-    uint32_t rp = mozilla::net::RP_Unset;
-
-    nsresult rv = mLoadInfo.mCSP->GetReferrerPolicy(&rp, &hasReferrerPolicy);
-    NS_ENSURE_SUCCESS_VOID(rv);
-
-    if (hasReferrerPolicy) {
-      mLoadInfo.mReferrerPolicy = static_cast<net::ReferrerPolicy>(rp);
-    }
-  } else {
-    mLoadInfo.mEvalAllowed = true;
-    mLoadInfo.mReportCSPViolations = false;
-  }
-
-  mLoadInfo.mLoadGroup = aLoadGroup;
-
-  mLoadInfo.mPrincipalInfo = new PrincipalInfo();
-  mLoadInfo.mOriginAttributes = nsContentUtils::GetOriginAttributes(aLoadGroup);
-
-  MOZ_ALWAYS_SUCCEEDS(
-    PrincipalToPrincipalInfo(aPrincipal, mLoadInfo.mPrincipalInfo));
-}
+WorkerPrivateParent<Derived>::SetPrincipalOnMainThread(nsIPrincipal* aPrincipal,
+                                                       nsILoadGroup* aLoadGroup)
+{
+  mLoadInfo.SetPrincipalOnMainThread(aPrincipal, aLoadGroup);
+}
+
+template <class Derived>
+nsresult
+WorkerPrivateParent<Derived>::SetPrincipalFromChannel(nsIChannel* aChannel)
+{
+  return mLoadInfo.SetPrincipalFromChannel(aChannel);
+}
+
+#if defined(DEBUG) || !defined(RELEASE_OR_BETA)
+template <class Derived>
+bool
+WorkerPrivateParent<Derived>::FinalChannelPrincipalIsValid(nsIChannel* aChannel)
+{
+  return mLoadInfo.FinalChannelPrincipalIsValid(aChannel);
+}
+#endif
 
 template <class Derived>
 void
 WorkerPrivateParent<Derived>::UpdateOverridenLoadGroup(nsILoadGroup* aBaseLoadGroup)
 {
   AssertIsOnMainThread();
 
   // The load group should have been overriden at init time.
@@ -4442,32 +4573,34 @@ WorkerPrivate::GetLoadInfo(JSContext* aC
       MutexAutoLock lock(aParent->mMutex);
       parentStatus = aParent->mStatus;
     }
 
     if (parentStatus > Running) {
       return NS_ERROR_FAILURE;
     }
 
-    // StartAssignment() is used instead getter_AddRefs because, getter_AddRefs
-    // does QI in debug build and, if this worker runs in a child process,
-    // HttpChannelChild will crash because it's not thread-safe.
+    // Passing a pointer to our stack loadInfo is safe here because this
+    // method uses a sync runnable to get the channel from the main thread.
     rv = ChannelFromScriptURLWorkerThread(aCx, aParent, aScriptURL,
-                                          loadInfo.mChannel.StartAssignment());
-    NS_ENSURE_SUCCESS(rv, rv);
+                                          loadInfo);
+    if (NS_FAILED(rv)) {
+      MOZ_ALWAYS_TRUE(loadInfo.ProxyReleaseMainThreadObjects(aParent));
+      return rv;
+    }
 
     // Now that we've spun the loop there's no guarantee that our parent is
     // still alive.  We may have received control messages initiating shutdown.
     {
       MutexAutoLock lock(aParent->mMutex);
       parentStatus = aParent->mStatus;
     }
 
     if (parentStatus > Running) {
-      NS_ReleaseOnMainThread(loadInfo.mChannel.forget());
+      MOZ_ALWAYS_TRUE(loadInfo.ProxyReleaseMainThreadObjects(aParent));
       return NS_ERROR_FAILURE;
     }
 
     loadInfo.mDomain = aParent->Domain();
     loadInfo.mFromWindow = aParent->IsFromWindow();
     loadInfo.mWindowID = aParent->WindowID();
     loadInfo.mStorageAllowed = aParent->IsStorageAllowed();
     loadInfo.mOriginAttributes = aParent->GetOriginAttributes();
@@ -4657,16 +4790,19 @@ WorkerPrivate::GetLoadInfo(JSContext* aC
                                         ContentPolicyType(aWorkerType),
                                         useDefaultEncoding,
                                         getter_AddRefs(loadInfo.mChannel));
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = NS_GetFinalChannelURI(loadInfo.mChannel,
                                getter_AddRefs(loadInfo.mResolvedScriptURI));
     NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = loadInfo.SetPrincipalFromChannel(loadInfo.mChannel);
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
   aLoadInfo->StealFrom(loadInfo);
   return NS_OK;
 }
 
 // static
 void

--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -348,21 +348,18 @@ public:
   }
 
   bool
   Close();
 
   bool
   ModifyBusyCount(bool aIncrease);
 
-  void
-  ForgetOverridenLoadGroup(nsCOMPtr<nsILoadGroup>& aLoadGroupOut);
-
-  void
-  ForgetMainThreadObjects(nsTArray<nsCOMPtr<nsISupports> >& aDoomed);
+  bool
+  ProxyReleaseMainThreadObjects();
 
   void
   PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
               const Sequence<JSObject*>& aTransferable,
               ErrorResult& aRv);
 
   void
   UpdateContextOptions(const JS::ContextOptions& aContextOptions);
@@ -606,17 +603,25 @@ public:
   // access occurs on the main thread.
   nsIPrincipal*
   GetPrincipalDontAssertMainThread() const
   {
       return mLoadInfo.mPrincipal;
   }
 
   void
-  SetPrincipal(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup);
+  SetPrincipalOnMainThread(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup);
+
+  nsresult
+  SetPrincipalFromChannel(nsIChannel* aChannel);
+
+#if defined(DEBUG) || !defined(RELEASE_OR_BETA)
+  bool
+  FinalChannelPrincipalIsValid(nsIChannel* aChannel);
+#endif
 
   bool
   UsesSystemPrincipal() const
   {
     return mLoadInfo.mPrincipalIsSystem;
   }
 
   const PrincipalInfo&

--- a/dom/workers/Workers.h
+++ b/dom/workers/Workers.h
@@ -272,16 +272,39 @@ struct WorkerLoadInfo
   bool mStorageAllowed;
   bool mServiceWorkersTestingInWindow;
   OriginAttributes mOriginAttributes;
 
   WorkerLoadInfo();
   ~WorkerLoadInfo();
 
   void StealFrom(WorkerLoadInfo& aOther);
+
+  void
+  SetPrincipalOnMainThread(nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup);
+
+  nsresult
+  GetPrincipalAndLoadGroupFromChannel(nsIChannel* aChannel,
+                                      nsIPrincipal** aPrincipalOut,
+                                      nsILoadGroup** aLoadGroupOut);
+
+  nsresult
+  SetPrincipalFromChannel(nsIChannel* aChannel);
+
+#if defined(DEBUG) || !defined(RELEASE_OR_BETA)
+  bool
+  FinalChannelPrincipalIsValid(nsIChannel* aChannel);
+#endif
+
+  bool
+  ProxyReleaseMainThreadObjects(WorkerPrivate* aWorkerPrivate);
+
+  bool
+  ProxyReleaseMainThreadObjects(WorkerPrivate* aWorkerPrivate,
+                                nsCOMPtr<nsILoadGroup>& aLoadGroupToCancel);
 };
 
 // All of these are implemented in RuntimeService.cpp
 
 void
 CancelWorkersForWindow(nsPIDOMWindowInner* aWindow);
 
 void

--- a/dom/workers/test/WorkerTest_badworker.js
+++ b/dom/workers/test/WorkerTest_badworker.js
@@ -1,7 +1,1 @@
-/**
- * Any copyright is dedicated to the Public Domain.
- * http://creativecommons.org/publicdomain/zero/1.0/
- */
-onmessage = function(event) {
-  throw "Shouldn't be able to read this!";
-}
+// doesn't matter what is in here if the URL is bad

--- a/dom/workers/test/WorkerTest_subworker.js
+++ b/dom/workers/test/WorkerTest_subworker.js
@@ -16,28 +16,18 @@ onmessage = function(event) {
   xhr.open("GET", mochitestURL, false);
   xhr.send();
 
   if (!xhr.responseText) {
     throw "Can't load script file via XHR!";
   }
 
   // We shouldn't be able to make a ChromeWorker to a non-chrome URL.
-  let worker = new ChromeWorker(mochitestURL);
-  worker.onmessage = function(event) {
-    throw event.data;
-  };
-  worker.onerror = function(event) {
-    event.preventDefault();
-
-    // And we shouldn't be able to make a regular Worker to a non-chrome URL.
-    worker = new Worker(mochitestURL);
-    worker.onmessage = function(event) {
-      throw event.data;
-    };
-    worker.onerror = function(event) {
-      event.preventDefault();
+  try{
+    new ChromeWorker(mochitestURL);
+  } catch(e) {
+    if (e.name === 'SecurityError') {
       postMessage("Done");
-    };
-    worker.postMessage("Hi");
-  };
-  worker.postMessage("Hi");
+      return;
+    }
+  }
+  throw('creating a chrome worker with a bad URL should throw a SecurityError');
 };

--- a/image/FrameAnimator.cpp
+++ b/image/FrameAnimator.cpp
@@ -506,18 +506,18 @@ FrameAnimator::DoBlend(IntRect* aDirtyRe
     return true;
   }
 
   bool needToBlankComposite = false;
 
   // Create the Compositing Frame
   if (!mCompositingFrame) {
     RefPtr<imgFrame> newFrame = new imgFrame;
-    nsresult rv = newFrame->InitForDecoder(mSize,
-                                           SurfaceFormat::B8G8R8A8);
+    nsresult rv = newFrame->InitForAnimator(mSize,
+                                            SurfaceFormat::B8G8R8A8);
     if (NS_FAILED(rv)) {
       mCompositingFrame.reset();
       return false;
     }
     mCompositingFrame = newFrame->RawAccessRef();
     needToBlankComposite = true;
   } else if (int32_t(aNextFrameIndex) != mLastCompositedFrameIndex+1) {
 
@@ -647,18 +647,18 @@ FrameAnimator::DoBlend(IntRect* aDirtyRe
   // too
   if ((nextFrameData.mDisposalMethod == DisposalMethod::RESTORE_PREVIOUS) &&
       (prevFrameData.mDisposalMethod != DisposalMethod::RESTORE_PREVIOUS)) {
     // We are storing the whole image.
     // It would be better if we just stored the area that nextFrame is going to
     // overwrite.
     if (!mCompositingPrevFrame) {
       RefPtr<imgFrame> newFrame = new imgFrame;
-      nsresult rv = newFrame->InitForDecoder(mSize,
-                                             SurfaceFormat::B8G8R8A8);
+      nsresult rv = newFrame->InitForAnimator(mSize,
+                                              SurfaceFormat::B8G8R8A8);
       if (NS_FAILED(rv)) {
         mCompositingPrevFrame.reset();
         return false;
       }
 
       mCompositingPrevFrame = newFrame->RawAccessRef();
     }
 

--- a/image/RasterImage.cpp
+++ b/image/RasterImage.cpp
@@ -600,17 +600,17 @@ RasterImage::GetImageContainer(LayerMana
   DrawResult drawResult;
   RefPtr<layers::Image> image;
   Tie(drawResult, image) = GetCurrentImage(container, aFlags);
   if (!image) {
     return nullptr;
   }
 
   // |image| holds a reference to a SourceSurface which in turn holds a lock on
-  // the current frame's VolatileBuffer, ensuring that it doesn't get freed as
+  // the current frame's data buffer, ensuring that it doesn't get freed as
   // long as the layer system keeps this ImageContainer alive.
   AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
   imageList.AppendElement(ImageContainer::NonOwningImage(image, TimeStamp(),
                                                          mLastFrameID++,
                                                          mImageProducerID));
   container->SetCurrentImagesInTransaction(imageList);
 
   mLastImageContainerDrawResult = drawResult;

--- a/image/imgFrame.cpp
+++ b/image/imgFrame.cpp
@@ -15,99 +15,99 @@
 #include "gfxPrefs.h"
 #include "gfxUtils.h"
 #include "gfxAlphaRecovery.h"
 
 #include "GeckoProfiler.h"
 #include "MainThreadUtils.h"
 #include "mozilla/CheckedInt.h"
 #include "mozilla/gfx/Tools.h"
+#include "mozilla/layers/SourceSurfaceVolatileData.h"
 #include "mozilla/Likely.h"
 #include "mozilla/MemoryReporting.h"
 #include "nsMargin.h"
 #include "nsThreadUtils.h"
 
 
 namespace mozilla {
 
 using namespace gfx;
 
 namespace image {
 
 static void
-VolatileBufferRelease(void* vbuf)
+ScopedMapRelease(void* aMap)
 {
-  delete static_cast<VolatileBufferPtr<unsigned char>*>(vbuf);
+  delete static_cast<DataSourceSurface::ScopedMap*>(aMap);
 }
 
 static int32_t
 VolatileSurfaceStride(const IntSize& size, SurfaceFormat format)
 {
   // Stride must be a multiple of four or cairo will complain.
   return (size.width * BytesPerPixel(format) + 0x3) & ~0x3;
 }
 
 static already_AddRefed<DataSourceSurface>
-CreateLockedSurface(VolatileBuffer* vbuf,
+CreateLockedSurface(DataSourceSurface *aSurface,
                     const IntSize& size,
                     SurfaceFormat format)
 {
-  VolatileBufferPtr<unsigned char>* vbufptr =
-    new VolatileBufferPtr<unsigned char>(vbuf);
-  MOZ_ASSERT(!vbufptr->WasBufferPurged(), "Expected image data!");
-
-  const int32_t stride = VolatileSurfaceStride(size, format);
-
-  // The VolatileBufferPtr is held by this DataSourceSurface.
-  RefPtr<DataSourceSurface> surf =
-    Factory::CreateWrappingDataSourceSurface(*vbufptr, stride, size, format,
-                                             &VolatileBufferRelease,
-                                             static_cast<void*>(vbufptr));
-  if (!surf) {
-    delete vbufptr;
-    return nullptr;
+  DataSourceSurface::ScopedMap* smap =
+    new DataSourceSurface::ScopedMap(aSurface, DataSourceSurface::READ_WRITE);
+  if (smap->IsMapped()) {
+    // The ScopedMap is held by this DataSourceSurface.
+    RefPtr<DataSourceSurface> surf =
+      Factory::CreateWrappingDataSourceSurface(smap->GetData(),
+                                               aSurface->Stride(),
+                                               size,
+                                               format,
+                                               &ScopedMapRelease,
+                                               static_cast<void*>(smap));
+    if (surf) {
+      return surf.forget();
+    }
   }
 
-  return surf.forget();
+  delete smap;
+  return nullptr;
 }
 
-static already_AddRefed<VolatileBuffer>
-AllocateBufferForImage(const IntSize& size, SurfaceFormat format)
+static already_AddRefed<DataSourceSurface>
+AllocateBufferForImage(const IntSize& size,
+                       SurfaceFormat format,
+                       bool aIsAnimated = false)
 {
   int32_t stride = VolatileSurfaceStride(size, format);
-  RefPtr<VolatileBuffer> buf = new VolatileBuffer();
-  if (buf->Init(stride * size.height,
-                size_t(1) << gfxAlphaRecovery::GoodAlignmentLog2())) {
-    return buf.forget();
+  RefPtr<SourceSurfaceVolatileData> newSurf = new SourceSurfaceVolatileData();
+  if (newSurf->Init(size, stride, format)) {
+    return newSurf.forget();
   }
 
   return nullptr;
 }
 
 static bool
-ClearSurface(VolatileBuffer* aVBuf, const IntSize& aSize, SurfaceFormat aFormat)
+ClearSurface(DataSourceSurface* aSurface, const IntSize& aSize, SurfaceFormat aFormat)
 {
-  VolatileBufferPtr<unsigned char> vbufptr(aVBuf);
-  if (vbufptr.WasBufferPurged()) {
-    NS_WARNING("VolatileBuffer was purged");
-    return false;
-  }
+  int32_t stride = aSurface->Stride();
+  uint8_t* data = aSurface->GetData();
+  MOZ_ASSERT(data);
 
-  int32_t stride = VolatileSurfaceStride(aSize, aFormat);
   if (aFormat == SurfaceFormat::B8G8R8X8) {
     // Skia doesn't support RGBX surfaces, so ensure the alpha value is set
     // to opaque white. While it would be nice to only do this for Skia,
     // imgFrame can run off main thread and past shutdown where
     // we might not have gfxPlatform, so just memset everytime instead.
-    memset(vbufptr, 0xFF, stride * aSize.height);
-  } else if (aVBuf->OnHeap()) {
+    memset(data, 0xFF, stride * aSize.height);
+  } else if (aSurface->OnHeap()) {
     // We only need to memset it if the buffer was allocated on the heap.
     // Otherwise, it's allocated via mmap and refers to a zeroed page and will
     // be COW once it's written to.
-    memset(vbufptr, 0, stride * aSize.height);
+    memset(data, 0, stride * aSize.height);
   }
 
   return true;
 }
 
 // Returns true if an image of aWidth x aHeight is allowed and legal.
 static bool
 AllowedImageSize(int32_t aWidth, int32_t aHeight)
@@ -186,17 +186,18 @@ imgFrame::~imgFrame()
   mPalettedImageData = nullptr;
 }
 
 nsresult
 imgFrame::InitForDecoder(const nsIntSize& aImageSize,
                          const nsIntRect& aRect,
                          SurfaceFormat aFormat,
                          uint8_t aPaletteDepth /* = 0 */,
-                         bool aNonPremult /* = false */)
+                         bool aNonPremult /* = false */,
+                         bool aIsAnimated /* = false */)
 {
   // Assert for properties that should be verified by decoders,
   // warn for properties related to bad content.
   if (!AllowedImageAndFrameDimensions(aImageSize, aRect)) {
     NS_WARNING("Should have legal image size");
     mAborted = true;
     return NS_ERROR_FAILURE;
   }
@@ -234,33 +235,32 @@ imgFrame::InitForDecoder(const nsIntSize
     // pixel, so calculating the amount of memory we need is straightforward.
     size_t dataSize = PaletteDataLength() + mFrameRect.Area();
     mPalettedImageData = static_cast<uint8_t*>(calloc(dataSize, sizeof(uint8_t)));
     if (!mPalettedImageData) {
       NS_WARNING("Call to calloc for paletted image data should succeed");
     }
     NS_ENSURE_TRUE(mPalettedImageData, NS_ERROR_OUT_OF_MEMORY);
   } else {
-    MOZ_ASSERT(!mImageSurface, "Called imgFrame::InitForDecoder() twice?");
+    MOZ_ASSERT(!mLockedSurface, "Called imgFrame::InitForDecoder() twice?");
 
-    mVBuf = AllocateBufferForImage(mFrameRect.Size(), mFormat);
-    if (!mVBuf) {
+    mRawSurface = AllocateBufferForImage(mFrameRect.Size(), mFormat, aIsAnimated);
+    if (!mRawSurface) {
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
-    mImageSurface = CreateLockedSurface(mVBuf, mFrameRect.Size(), mFormat);
-
-    if (!mImageSurface) {
-      NS_WARNING("Failed to create ImageSurface");
+    mLockedSurface = CreateLockedSurface(mRawSurface, mFrameRect.Size(), mFormat);
+    if (!mLockedSurface) {
+      NS_WARNING("Failed to create LockedSurface");
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
-    if (!ClearSurface(mVBuf, mFrameRect.Size(), mFormat)) {
+    if (!ClearSurface(mRawSurface, mFrameRect.Size(), mFormat)) {
       NS_WARNING("Could not clear allocated buffer");
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
   }
 
   return NS_OK;
 }
@@ -290,49 +290,41 @@ imgFrame::InitWithDrawable(gfxDrawable* 
   RefPtr<DrawTarget> target;
 
   bool canUseDataSurface =
     gfxPlatform::GetPlatform()->CanRenderContentToDataSurface();
 
   if (canUseDataSurface) {
     // It's safe to use data surfaces for content on this platform, so we can
     // get away with using volatile buffers.
-    MOZ_ASSERT(!mImageSurface, "Called imgFrame::InitWithDrawable() twice?");
+    MOZ_ASSERT(!mLockedSurface, "Called imgFrame::InitWithDrawable() twice?");
 
-    mVBuf = AllocateBufferForImage(mFrameRect.Size(), mFormat);
-    if (!mVBuf) {
+    mRawSurface = AllocateBufferForImage(mFrameRect.Size(), mFormat);
+    if (!mRawSurface) {
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
-    int32_t stride = VolatileSurfaceStride(mFrameRect.Size(), mFormat);
-    VolatileBufferPtr<uint8_t> ptr(mVBuf);
-    if (!ptr) {
+    mLockedSurface = CreateLockedSurface(mRawSurface, mFrameRect.Size(), mFormat);
+    if (!mLockedSurface) {
+      NS_WARNING("Failed to create LockedSurface");
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
-    mImageSurface = CreateLockedSurface(mVBuf, mFrameRect.Size(), mFormat);
-
-    if (!mImageSurface) {
-      NS_WARNING("Failed to create ImageSurface");
-      mAborted = true;
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    if (!ClearSurface(mVBuf, mFrameRect.Size(), mFormat)) {
+    if (!ClearSurface(mRawSurface, mFrameRect.Size(), mFormat)) {
       NS_WARNING("Could not clear allocated buffer");
       mAborted = true;
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     target = gfxPlatform::CreateDrawTargetForData(
-                            ptr,
+                            mLockedSurface->GetData(),
                             mFrameRect.Size(),
-                            stride,
+                            mLockedSurface->Stride(),
                             mFormat);
   } else {
     // We can't use data surfaces for content, so we'll create an offscreen
     // surface instead.  This means if someone later calls RawAccessRef(), we
     // may have to do an expensive readback, but we warned callers about that in
     // the documentation for this method.
     MOZ_ASSERT(!mOptSurface, "Called imgFrame::InitWithDrawable() twice?");
 
@@ -352,17 +344,17 @@ imgFrame::InitWithDrawable(gfxDrawable* 
 
   // Draw using the drawable the caller provided.
   RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(target);
   MOZ_ASSERT(ctx);  // Already checked the draw target above.
   gfxUtils::DrawPixelSnapped(ctx, aDrawable, mFrameRect.Size(),
                              ImageRegion::Create(ThebesRect(mFrameRect)),
                              mFormat, aSamplingFilter, aImageFlags);
 
-  if (canUseDataSurface && !mImageSurface) {
+  if (canUseDataSurface && !mLockedSurface) {
     NS_WARNING("Failed to create VolatileDataSourceSurface");
     mAborted = true;
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   if (!canUseDataSurface) {
     // We used an offscreen surface, which is an "optimized" surface from
     // imgFrame's perspective.
@@ -417,33 +409,33 @@ imgFrame::Optimize(DrawTarget* aTarget)
 
   // XXX(seth): It's currently unclear if there's any reason why we can't
   // optimize non-premult surfaces. We should look into removing this.
   if (mNonPremult) {
     return NS_OK;
   }
 
   mOptSurface = gfxPlatform::GetPlatform()
-    ->ScreenReferenceDrawTarget()->OptimizeSourceSurface(mImageSurface);
-  if (mOptSurface == mImageSurface) {
+    ->ScreenReferenceDrawTarget()->OptimizeSourceSurface(mLockedSurface);
+  if (mOptSurface == mLockedSurface) {
     mOptSurface = nullptr;
   }
 
   if (mOptSurface) {
-    // There's no reason to keep our volatile buffer around at all if we have an
+    // There's no reason to keep our original surface around if we have an
     // optimized surface. Release our reference to it. This will leave
-    // |mVBufPtr| and |mImageSurface| as the only things keeping it alive, so
-    // it'll get freed below.
-    mVBuf = nullptr;
+    // |mLockedSurface| as the only thing keeping it alive, so it'll get freed
+    // below.
+    mRawSurface = nullptr;
   }
 
-  // Release all strong references to our volatile buffer's memory. This will
-  // allow the operating system to free the memory if it needs to.
-  mVBufPtr = nullptr;
-  mImageSurface = nullptr;
+  // Release all strong references to the surface's memory. If the underlying
+  // surface is volatile, this will allow the operating system to free the
+  // memory if it needs to.
+  mLockedSurface = nullptr;
   mOptimizable = false;
 
   return NS_OK;
 }
 
 DrawableFrameRef
 imgFrame::DrawableRef()
 {
@@ -531,17 +523,17 @@ bool imgFrame::Draw(gfxContext* aContext
   if (mPalettedImageData) {
     MOZ_ASSERT_UNREACHABLE("Directly drawing a paletted image!");
     return false;
   }
 
   MonitorAutoLock lock(mMonitor);
 
   // Possibly convert this image into a GPU texture, this may also cause our
-  // mImageSurface to be released and the OS to release the underlying memory.
+  // mLockedSurface to be released and the OS to release the underlying memory.
   Optimize(aContext->GetDrawTarget());
 
   bool doPartialDecode = !AreAllPixelsWritten();
 
   RefPtr<SourceSurface> surf = GetSourceSurfaceInternal();
   if (!surf) {
     return false;
   }
@@ -605,17 +597,17 @@ imgFrame::Finish(Opacity aFrameOpacity /
   mMonitor.NotifyAll();
 }
 
 uint32_t
 imgFrame::GetImageBytesPerRow() const
 {
   mMonitor.AssertCurrentThreadOwns();
 
-  if (mVBuf) {
+  if (mRawSurface) {
     return mFrameRect.width * BytesPerPixel(mFormat);
   }
 
   if (mPaletteDepth) {
     return mFrameRect.width;
   }
 
   return 0;
@@ -635,27 +627,27 @@ imgFrame::GetImageData(uint8_t** aData, 
 }
 
 void
 imgFrame::GetImageDataInternal(uint8_t** aData, uint32_t* aLength) const
 {
   mMonitor.AssertCurrentThreadOwns();
   MOZ_ASSERT(mLockCount > 0, "Image data should be locked");
 
-  if (mImageSurface) {
-    *aData = mVBufPtr;
+  if (mLockedSurface) {
+    *aData = mLockedSurface->GetData();
     MOZ_ASSERT(*aData,
-      "mImageSurface is non-null, but mVBufPtr is null in GetImageData");
+      "mLockedSurface is non-null, but GetData is null in GetImageData");
   } else if (mPalettedImageData) {
     *aData = mPalettedImageData + PaletteDataLength();
     MOZ_ASSERT(*aData,
       "mPalettedImageData is non-null, but result is null in GetImageData");
   } else {
     MOZ_ASSERT(false,
-      "Have neither mImageSurface nor mPalettedImageData in GetImageData");
+      "Have neither mLockedSurface nor mPalettedImageData in GetImageData");
     *aData = nullptr;
   }
 
   *aLength = GetImageDataLength();
 }
 
 uint8_t*
 imgFrame::GetImageData() const
@@ -707,19 +699,18 @@ imgFrame::LockImageData()
 
   mLockCount++;
 
   // If we are not the first lock, there's nothing to do.
   if (mLockCount != 1) {
     return NS_OK;
   }
 
-  // If we're the first lock, but have an image surface, we're OK.
-  if (mImageSurface) {
-    mVBufPtr = mVBuf;
+  // If we're the first lock, but have the locked surface, we're OK.
+  if (mLockedSurface) {
     return NS_OK;
   }
 
   // Paletted images don't have surfaces, so there's nothing to do.
   if (mPalettedImageData) {
     return NS_OK;
   }
 
@@ -778,31 +769,22 @@ imgFrame::GetSourceSurfaceInternal()
     if (mOptSurface->IsValid()) {
       RefPtr<SourceSurface> surf(mOptSurface);
       return surf.forget();
     } else {
       mOptSurface = nullptr;
     }
   }
 
-  if (mImageSurface) {
-    RefPtr<SourceSurface> surf(mImageSurface);
+  if (mLockedSurface) {
+    RefPtr<SourceSurface> surf(mLockedSurface);
     return surf.forget();
   }
 
-  if (!mVBuf) {
-    return nullptr;
-  }
-
-  VolatileBufferPtr<char> buf(mVBuf);
-  if (buf.WasBufferPurged()) {
-    return nullptr;
-  }
-
-  return CreateLockedSurface(mVBuf, mFrameRect.Size(), mFormat);
+  return CreateLockedSurface(mRawSurface, mFrameRect.Size(), mFormat);
 }
 
 AnimationData
 imgFrame::GetAnimationData() const
 {
   MonitorAutoLock lock(mMonitor);
   MOZ_ASSERT(mLockCount > 0, "Image data should be locked");
 
@@ -886,24 +868,23 @@ imgFrame::AddSizeOfExcludingThis(MallocS
                                  size_t& aHeapSizeOut,
                                  size_t& aNonHeapSizeOut) const
 {
   MonitorAutoLock lock(mMonitor);
 
   if (mPalettedImageData) {
     aHeapSizeOut += aMallocSizeOf(mPalettedImageData);
   }
-  if (mImageSurface) {
-    aHeapSizeOut += aMallocSizeOf(mImageSurface);
+  if (mLockedSurface) {
+    aHeapSizeOut += aMallocSizeOf(mLockedSurface);
   }
   if (mOptSurface) {
     aHeapSizeOut += aMallocSizeOf(mOptSurface);
   }
-
-  if (mVBuf) {
-    aHeapSizeOut += aMallocSizeOf(mVBuf);
-    aHeapSizeOut += mVBuf->HeapSizeOfExcludingThis(aMallocSizeOf);
-    aNonHeapSizeOut += mVBuf->NonHeapSizeOfExcludingThis();
+  if (mRawSurface) {
+    aHeapSizeOut += aMallocSizeOf(mRawSurface);
+    mRawSurface->AddSizeOfExcludingThis(aMallocSizeOf, aHeapSizeOut,
+                                        aNonHeapSizeOut);
   }
 }
 
 } // namespace image
 } // namespace mozilla

--- a/image/imgFrame.h
+++ b/image/imgFrame.h
@@ -6,20 +6,20 @@
 
 #ifndef mozilla_image_imgFrame_h
 #define mozilla_image_imgFrame_h
 
 #include "mozilla/Maybe.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Monitor.h"
 #include "mozilla/Move.h"
-#include "mozilla/VolatileBuffer.h"
 #include "gfxDrawable.h"
 #include "imgIContainer.h"
 #include "MainThreadUtils.h"
+#include "nsAutoPtr.h"
 
 namespace mozilla {
 namespace image {
 
 class ImageRegion;
 class DrawableFrameRef;
 class RawAccessFrameRef;
 
@@ -205,24 +205,24 @@ public:
    * This is appropriate for use with decoded images, but it should not be used
    * when drawing content into an imgFrame, as it may use a different graphics
    * backend than normal content drawing.
    */
   nsresult InitForDecoder(const nsIntSize& aImageSize,
                           const nsIntRect& aRect,
                           SurfaceFormat aFormat,
                           uint8_t aPaletteDepth = 0,
-                          bool aNonPremult = false);
+                          bool aNonPremult = false,
+                          bool aIsAnimated = false);
 
-  nsresult InitForDecoder(const nsIntSize& aSize,
-                          SurfaceFormat aFormat,
-                          uint8_t aPaletteDepth = 0)
+  nsresult InitForAnimator(const nsIntSize& aSize,
+                           SurfaceFormat aFormat)
   {
     return InitForDecoder(aSize, nsIntRect(0, 0, aSize.width, aSize.height),
-                          aFormat, aPaletteDepth);
+                          aFormat, 0, false, true);
   }
 
 
   /**
    * Initialize this imgFrame with a new surface and draw the provided
    * gfxDrawable into it.
    *
    * This is appropriate to use when drawing content into an imgFrame, as it
@@ -390,21 +390,35 @@ private: // data
   friend class UnlockImageDataRunnable;
 
   //////////////////////////////////////////////////////////////////////////////
   // Thread-safe mutable data, protected by mMonitor.
   //////////////////////////////////////////////////////////////////////////////
 
   mutable Monitor mMonitor;
 
-  RefPtr<DataSourceSurface> mImageSurface;
-  RefPtr<SourceSurface> mOptSurface;
+  /**
+   * Surface which contains either a weak or a strong reference to its
+   * underlying data buffer. If it is a weak reference, and there are no strong
+   * references, the buffer may be released due to events such as low memory.
+   */
+  RefPtr<DataSourceSurface> mRawSurface;
 
-  RefPtr<VolatileBuffer> mVBuf;
-  VolatileBufferPtr<uint8_t> mVBufPtr;
+  /**
+   * Refers to the same data as mRawSurface, but when set, it guarantees that
+   * we hold a strong reference to the underlying data buffer.
+   */
+  RefPtr<DataSourceSurface> mLockedSurface;
+
+  /**
+   * Optimized copy of mRawSurface for the DrawTarget that will render it. This
+   * is unused if the DrawTarget is able to render DataSourceSurface buffers
+   * directly.
+   */
+  RefPtr<SourceSurface> mOptSurface;
 
   nsIntRect mDecoded;
 
   //! Number of RawAccessFrameRefs currently alive for this imgFrame.
   int32_t mLockCount;
 
   //! The timeout for this frame.
   FrameTimeout mTimeout;
@@ -445,26 +459,37 @@ private: // data
 
 /**
  * A reference to an imgFrame that holds the imgFrame's surface in memory,
  * allowing drawing. If you have a DrawableFrameRef |ref| and |if (ref)| returns
  * true, then calls to Draw() and GetSourceSurface() are guaranteed to succeed.
  */
 class DrawableFrameRef final
 {
+  typedef gfx::DataSourceSurface DataSourceSurface;
+
 public:
   DrawableFrameRef() { }
 
   explicit DrawableFrameRef(imgFrame* aFrame)
     : mFrame(aFrame)
-    , mRef(aFrame->mVBuf)
   {
-    if (mRef.WasBufferPurged()) {
-      mFrame = nullptr;
-      mRef = nullptr;
+    // Paletted images won't have a surface so there is no strong reference
+    // to hold on to. Since Draw() and GetSourceSurface() calls will not work
+    // in that case, we should be using RawAccessFrameRef exclusively instead.
+    // See FrameAnimator::GetRawFrame for an example of this behaviour.
+    if (aFrame->mRawSurface) {
+      mRef = new DataSourceSurface::ScopedMap(aFrame->mRawSurface,
+                                              DataSourceSurface::READ_WRITE);
+      if (!mRef->IsMapped()) {
+        mFrame = nullptr;
+        mRef = nullptr;
+      }
+    } else {
+      MOZ_ASSERT(aFrame->mOptSurface || aFrame->GetIsPaletted());
     }
   }
 
   DrawableFrameRef(DrawableFrameRef&& aOther)
     : mFrame(aOther.mFrame.forget())
     , mRef(Move(aOther.mRef))
   { }
 
@@ -498,17 +523,17 @@ public:
     mFrame = nullptr;
     mRef = nullptr;
   }
 
 private:
   DrawableFrameRef(const DrawableFrameRef& aOther) = delete;
 
   RefPtr<imgFrame> mFrame;
-  VolatileBufferPtr<uint8_t> mRef;
+  nsAutoPtr<DataSourceSurface::ScopedMap> mRef;
 };
 
 /**
  * A reference to an imgFrame that holds the imgFrame's surface in memory in a
  * format appropriate for access as raw data. If you have a RawAccessFrameRef
  * |ref| and |if (ref)| is true, then calls to GetImageData() and
  * GetPaletteData() are guaranteed to succeed. This guarantee is stronger than
  * DrawableFrameRef, so everything that a valid DrawableFrameRef guarantees is

--- a/intl/locale/DateTimeFormat.h
+++ b/intl/locale/DateTimeFormat.h
@@ -10,16 +10,19 @@
 #include <time.h>
 #include "nsIScriptableDateFormat.h"
 #include "nsStringGlue.h"
 #include "prtime.h"
 
 #ifndef ENABLE_INTL_API
 #include "nsCOMPtr.h"
 #include "nsIUnicodeDecoder.h"
+#else
+#include "gtest/MozGtestFriend.h"
+#include "unicode/udat.h"
 #endif
 
 namespace mozilla {
 
 class DateTimeFormat {
 public:
   // performs a locale sensitive date formatting operation on the time_t parameter
   static nsresult FormatTime(const nsDateFormatSelector aDateFormatSelector,
@@ -42,16 +45,25 @@ public:
   static void Shutdown();
 
 private:
   DateTimeFormat() = delete;
 
   static nsresult Initialize();
 
 #ifdef ENABLE_INTL_API
+  FRIEND_TEST(DateTimeFormat, FormatPRExplodedTime);
+
+  // performs a locale sensitive date formatting operation on the UDate parameter
+  static nsresult FormatUDateTime(const nsDateFormatSelector aDateFormatSelector,
+                                  const nsTimeFormatSelector aTimeFormatSelector,
+                                  const UDate aUDateTime,
+                                  const PRTimeParameters* aTimeParameters,
+                                  nsAString& aStringOut);
+
   static nsCString* mLocale;
 #else
   // performs a locale sensitive date formatting operation on the struct tm parameter
   static nsresult FormatTMTime(const nsDateFormatSelector aDateFormatSelector,
                                const nsTimeFormatSelector aTimeFormatSelector,
                                const struct tm* aTmTime,
                                nsAString& aStringOut);
 

--- a/intl/locale/DateTimeFormatICU.cpp
+++ b/intl/locale/DateTimeFormatICU.cpp
@@ -3,17 +3,16 @@
  * 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 "DateTimeFormat.h"
 #include "nsCOMPtr.h"
 #include "nsIServiceManager.h"
 #include "nsILocaleService.h"
-#include "unicode/udat.h"
 
 namespace mozilla {
 
 nsCString* DateTimeFormat::mLocale = nullptr;
 
 /*static*/ nsresult
 DateTimeFormat::Initialize()
 {
@@ -54,16 +53,37 @@ DateTimeFormat::FormatTime(const nsDateF
 
 // performs a locale sensitive date formatting operation on the PRTime parameter
 /*static*/ nsresult
 DateTimeFormat::FormatPRTime(const nsDateFormatSelector aDateFormatSelector,
                              const nsTimeFormatSelector aTimeFormatSelector,
                              const PRTime aPrTime,
                              nsAString& aStringOut)
 {
+  return FormatUDateTime(aDateFormatSelector, aTimeFormatSelector, (aPrTime / PR_USEC_PER_MSEC), nullptr, aStringOut);
+}
+
+// performs a locale sensitive date formatting operation on the PRExplodedTime parameter
+/*static*/ nsresult
+DateTimeFormat::FormatPRExplodedTime(const nsDateFormatSelector aDateFormatSelector,
+                                     const nsTimeFormatSelector aTimeFormatSelector,
+                                     const PRExplodedTime* aExplodedTime,
+                                     nsAString& aStringOut)
+{
+  return FormatUDateTime(aDateFormatSelector, aTimeFormatSelector, (PR_ImplodeTime(aExplodedTime) / PR_USEC_PER_MSEC), &(aExplodedTime->tm_params), aStringOut);
+}
+
+// performs a locale sensitive date formatting operation on the UDate parameter
+/*static*/ nsresult
+DateTimeFormat::FormatUDateTime(const nsDateFormatSelector aDateFormatSelector,
+                                const nsTimeFormatSelector aTimeFormatSelector,
+                                const UDate aUDateTime,
+                                const PRTimeParameters* aTimeParameters,
+                                nsAString& aStringOut)
+{
 #define DATETIME_FORMAT_INITIAL_LEN 127
   int32_t dateTimeLen = 0;
   nsresult rv = NS_OK;
 
   // return, nothing to format
   if (aDateFormatSelector == kDateFormatNone && aTimeFormatSelector == kTimeFormatNone) {
     aStringOut.Truncate();
     return NS_OK;
@@ -71,18 +91,16 @@ DateTimeFormat::FormatPRTime(const nsDat
 
   // set up locale data
   rv = Initialize();
 
   if (NS_FAILED(rv)) {
     return rv;
   }
 
-  UDate timeUDate = aPrTime / PR_USEC_PER_MSEC;
-
   // Get the date style for the formatter:
   UDateFormatStyle dateStyle;
   switch (aDateFormatSelector) {
     case kDateFormatLong:
       dateStyle = UDAT_LONG;
       break;
     case kDateFormatShort:
       dateStyle = UDAT_SHORT;
@@ -111,50 +129,55 @@ DateTimeFormat::FormatPRTime(const nsDat
       NS_ERROR("Unknown nsTimeFormatSelector");
       return NS_ERROR_ILLEGAL_VALUE;
   }
 
   // generate date/time string
 
   UErrorCode status = U_ZERO_ERROR;
 
-  UDateFormat* dateTimeFormat = udat_open(timeStyle, dateStyle, mLocale->get(), nullptr, -1, nullptr, -1, &status);
+  UDateFormat* dateTimeFormat;
+  if (aTimeParameters) {
+    nsAutoString timeZoneID(u"GMT");
+
+    int32_t totalOffsetMinutes = (aTimeParameters->tp_gmt_offset + aTimeParameters->tp_dst_offset) / 60;
+    if (totalOffsetMinutes != 0) {
+      char sign = totalOffsetMinutes < 0 ? '-' : '+';
+      int32_t hours = abs(totalOffsetMinutes) / 60;
+      int32_t minutes = abs(totalOffsetMinutes) % 60;
+      timeZoneID.AppendPrintf("%c%02d:%02d", sign, hours, minutes);
+    }
+
+    dateTimeFormat = udat_open(timeStyle, dateStyle, mLocale->get(), reinterpret_cast<const UChar*>(timeZoneID.BeginReading()), timeZoneID.Length(), nullptr, -1, &status);
+  } else {
+    dateTimeFormat = udat_open(timeStyle, dateStyle, mLocale->get(), nullptr, -1, nullptr, -1, &status);
+  }
 
   if (U_SUCCESS(status) && dateTimeFormat) {
     aStringOut.SetLength(DATETIME_FORMAT_INITIAL_LEN);
-    dateTimeLen = udat_format(dateTimeFormat, timeUDate, reinterpret_cast<UChar*>(aStringOut.BeginWriting()), DATETIME_FORMAT_INITIAL_LEN, nullptr, &status);
+    dateTimeLen = udat_format(dateTimeFormat, aUDateTime, reinterpret_cast<UChar*>(aStringOut.BeginWriting()), DATETIME_FORMAT_INITIAL_LEN, nullptr, &status);
     aStringOut.SetLength(dateTimeLen);
 
     if (status == U_BUFFER_OVERFLOW_ERROR) {
       status = U_ZERO_ERROR;
-      udat_format(dateTimeFormat, timeUDate, reinterpret_cast<UChar*>(aStringOut.BeginWriting()), dateTimeLen, nullptr, &status);
+      udat_format(dateTimeFormat, aUDateTime, reinterpret_cast<UChar*>(aStringOut.BeginWriting()), dateTimeLen, nullptr, &status);
     }
   }
 
   if (U_FAILURE(status)) {
     rv = NS_ERROR_FAILURE;
   }
 
   if (dateTimeFormat) {
     udat_close(dateTimeFormat);
   }
 
   return rv;
 }
 
-// performs a locale sensitive date formatting operation on the PRExplodedTime parameter
-/*static*/ nsresult
-DateTimeFormat::FormatPRExplodedTime(const nsDateFormatSelector aDateFormatSelector,
-                                     const nsTimeFormatSelector aTimeFormatSelector,
-                                     const PRExplodedTime* aExplodedTime,
-                                     nsAString& aStringOut)
-{
-  return FormatPRTime(aDateFormatSelector, aTimeFormatSelector, PR_ImplodeTime(aExplodedTime), aStringOut);
-}
-
 /*static*/ void
 DateTimeFormat::Shutdown()
 {
   if (mLocale) {
     delete mLocale;
   }
 }
 

new file mode 100644
--- /dev/null
+++ b/intl/locale/tests/gtest/TestDateTimeFormat.cpp
@@ -0,0 +1,49 @@
+#include "gtest/gtest.h"
+#include "DateTimeFormat.h"
+
+namespace mozilla {
+
+TEST(DateTimeFormat, FormatPRExplodedTime) {
+  PRTime prTime = 0;
+  PRExplodedTime prExplodedTime;
+  PR_ExplodeTime(prTime, PR_GMTParameters, &prExplodedTime);
+
+  mozilla::DateTimeFormat::mLocale = new nsCString("en-US");
+
+  nsAutoString formattedTime;
+  nsresult rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("January 1, 1970 at 12:00:00 AM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 19, 0, 1, 0, 1970, 4, 0, { (19 * 60), 0 } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("January 1, 1970 at 12:19:00 AM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 0, 7, 1, 0, 1970, 4, 0, { (6 * 60 * 60), (1 * 60 * 60) } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("January 1, 1970 at 7:00:00 AM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 29, 11, 1, 0, 1970, 4, 0, { (10 * 60 * 60) + (29 * 60), (1 * 60 * 60) } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("January 1, 1970 at 11:29:00 AM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 37, 23, 31, 11, 1969, 3, 364, { -(23 * 60), 0 } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("December 31, 1969 at 11:37:00 PM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 0, 17, 31, 11, 1969, 3, 364, { -(7 * 60 * 60), 0 } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("December 31, 1969 at 5:00:00 PM", NS_ConvertUTF16toUTF8(formattedTime).get());
+
+  prExplodedTime = { 0, 0, 47, 14, 31, 11, 1969, 3, 364, { -((10 * 60 * 60) + (13 * 60)), (1 * 60 * 60) } };
+  rv = mozilla::DateTimeFormat::FormatPRExplodedTime(kDateFormatLong, kTimeFormatSeconds, &prExplodedTime, formattedTime);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_STREQ("December 31, 1969 at 2:47:00 PM", NS_ConvertUTF16toUTF8(formattedTime).get());
+}
+
+}

--- a/intl/locale/tests/gtest/moz.build
+++ b/intl/locale/tests/gtest/moz.build
@@ -4,15 +4,18 @@
 # 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/.
 
 UNIFIED_SOURCES += [
     'TestLocaleService.cpp',
 ]
 
 if CONFIG['ENABLE_INTL_API']:
-    UNIFIED_SOURCES += ['TestOSPreferences.cpp']
+    UNIFIED_SOURCES += [
+        'TestDateTimeFormat.cpp',
+        'TestOSPreferences.cpp',
+    ]
 
 LOCAL_INCLUDES += [
     '/intl/locale',
 ]
 
 FINAL_LIBRARY = 'xul-gtest'

--- a/js/src/builtin/DataViewObject.cpp
+++ b/js/src/builtin/DataViewObject.cpp
@@ -15,22 +15,22 @@
 #include "jscntxt.h"
 #include "jsnum.h"
 #include "jsobj.h"
 #ifdef XP_WIN
 # include "jswin.h"
 #endif
 #include "jswrapper.h"
 
+#include "jit/AtomicOperations.h"
 #include "js/Conversions.h"
 #include "vm/ArrayBufferObject.h"
 #include "vm/GlobalObject.h"
 #include "vm/Interpreter.h"
 #include "vm/SharedMem.h"
-#include "vm/TypedArrayCommon.h"
 #include "vm/WrapperObject.h"
 
 #include "gc/Nursery-inl.h"
 #include "gc/StoreBuffer-inl.h"
 #include "vm/ArrayBufferObject-inl.h"
 #include "vm/NativeObject-inl.h"
 
 using namespace js;

--- a/js/src/builtin/Intl.js
+++ b/js/src/builtin/Intl.js
@@ -3299,17 +3299,17 @@ function Intl_getDisplayNames(locales, o
     // 13. Let len be ? ToLength(? Get(keys, "length")).
     let len = ToLength(keys.length);
 
     // 14. Let i be 0.
     // 15. Repeat, while i < len
     for (let i = 0; i < len; i++) {
         // a. Let processedKey be ? ToString(? Get(keys, i)).
         // b. Perform ? CreateDataPropertyOrThrow(processedKeys, i, processedKey).
-        callFunction(std_Array_push, processedKeys, ToString(keys[i]));
+        _DefineDataProperty(processedKeys, i, ToString(keys[i]));
     }
 
     // 16. Let names be ? ComputeDisplayNames(r.[[locale]], style, processedKeys).
     const names = intl_ComputeDisplayNames(r.locale, style, processedKeys);
 
     // 17. Let values be ObjectCreate(%ObjectPrototype%).
     const values = {};
 

--- a/js/src/builtin/SIMD.cpp
+++ b/js/src/builtin/SIMD.cpp
@@ -18,16 +18,17 @@
 #include "mozilla/Sprintf.h"
 
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "jsnum.h"
 #include "jsprf.h"
 
 #include "builtin/TypedObject.h"
+#include "jit/AtomicOperations.h"
 #include "jit/InlinableNatives.h"
 #include "js/GCAPI.h"
 #include "js/Value.h"
 
 #include "jsobjinlines.h"
 
 using namespace js;
 

--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -39,16 +39,17 @@
 #include "jsfun.h"
 #include "jsnum.h"
 #include "jsprf.h"
 
 #include "builtin/TypedObject.h"
 #include "ctypes/Library.h"
 #include "gc/Policy.h"
 #include "gc/Zone.h"
+#include "jit/AtomicOperations.h"
 #include "js/Vector.h"
 
 #include "jsatominlines.h"
 #include "jsobjinlines.h"
 
 using namespace std;
 
 using JS::AutoCheckCannotGC;

--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -97,17 +97,17 @@ class BackgroundDecommitTask : public GC
 
     explicit BackgroundDecommitTask(JSRuntime *rt) : GCParallelTask(rt) {}
     void setChunksToScan(ChunkVector &chunks);
 
   protected:
     void run() override;
 
   private:
-    UnprotectedData<ChunkVector> toDecommit;
+    ActiveThreadOrGCTaskData<ChunkVector> toDecommit;
 };
 
 /*
  * Encapsulates all of the GC tunables. These are effectively constant and
  * should only be modified by setParameter.
  */
 class GCSchedulingTunables
 {
@@ -115,70 +115,70 @@ class GCSchedulingTunables
      * Soft limit on the number of bytes we are allowed to allocate in the GC
      * heap. Attempts to allocate gcthings over this limit will return null and
      * subsequently invoke the standard OOM machinery, independent of available
      * physical memory.
      */
     UnprotectedData<size_t> gcMaxBytes_;
 
     /* Maximum nursery size for each zone group. */
-    UnprotectedData<size_t> gcMaxNurseryBytes_;
+    ActiveThreadData<size_t> gcMaxNurseryBytes_;
 
     /*
      * The base value used to compute zone->trigger.gcBytes(). When
      * usage.gcBytes() surpasses threshold.gcBytes() for a zone, the zone may
      * be scheduled for a GC, depending on the exact circumstances.
      */
-    UnprotectedData<size_t> gcZoneAllocThresholdBase_;
+    ActiveThreadOrGCTaskData<size_t> gcZoneAllocThresholdBase_;
 
     /* Fraction of threshold.gcBytes() which triggers an incremental GC. */
     UnprotectedData<double> zoneAllocThresholdFactor_;
 
     /*
      * Number of bytes to allocate between incremental slices in GCs triggered
      * by the zone allocation threshold.
      */
     UnprotectedData<size_t> zoneAllocDelayBytes_;
 
     /*
      * Totally disables |highFrequencyGC|, the HeapGrowthFactor, and other
      * tunables that make GC non-deterministic.
      */
-    UnprotectedData<bool> dynamicHeapGrowthEnabled_;
+    ActiveThreadData<bool> dynamicHeapGrowthEnabled_;
 
     /*
      * We enter high-frequency mode if we GC a twice within this many
      * microseconds. This value is stored directly in microseconds.
      */
-    UnprotectedData<uint64_t> highFrequencyThresholdUsec_;
+    ActiveThreadData<uint64_t> highFrequencyThresholdUsec_;
 
     /*
      * When in the |highFrequencyGC| mode, these parameterize the per-zone
      * "HeapGrowthFactor" computation.
      */
-    UnprotectedData<uint64_t> highFrequencyLowLimitBytes_;
-    UnprotectedData<uint64_t> highFrequencyHighLimitBytes_;
-    UnprotectedData<double> highFrequencyHeapGrowthMax_;
-    UnprotectedData<double> highFrequencyHeapGrowthMin_;
+    ActiveThreadData<uint64_t> highFrequencyLowLimitBytes_;
+    ActiveThreadData<uint64_t> highFrequencyHighLimitBytes_;
+    ActiveThreadData<double> highFrequencyHeapGrowthMax_;
+    ActiveThreadData<double> highFrequencyHeapGrowthMin_;
 
     /*
      * When not in |highFrequencyGC| mode, this is the global (stored per-zone)
      * "HeapGrowthFactor".
      */
-    UnprotectedData<double> lowFrequencyHeapGrowth_;
+    ActiveThreadData<double> lowFrequencyHeapGrowth_;
 
     /*
      * Doubles the length of IGC slices when in the |highFrequencyGC| mode.
      */
-    UnprotectedData<bool> dynamicMarkSliceEnabled_;
+    ActiveThreadData<bool> dynamicMarkSliceEnabled_;
 
     /*
      * Controls whether painting can trigger IGC slices.
      */
-    UnprotectedData<bool> refreshFrameSlicesEnabled_;
+    ActiveThreadData<bool> refreshFrameSlicesEnabled_;
 
     /*
      * Controls the number of empty chunks reserved for future allocation.
      */
     UnprotectedData<uint32_t> minEmptyChunkCount_;
     UnprotectedData<uint32_t> maxEmptyChunkCount_;
 
   public:
@@ -521,17 +521,17 @@ class GCSchedulingTunables
 class GCSchedulingState
 {
     /*
      * Influences how we schedule and run GC's in several subtle ways. The most
      * important factor is in how it controls the "HeapGrowthFactor". The
      * growth factor is a measure of how large (as a percentage of the last GC)
      * the heap is allowed to grow before we try to schedule another GC.
      */
-    UnprotectedData<bool> inHighFrequencyGCMode_;
+    ActiveThreadData<bool> inHighFrequencyGCMode_;
 
   public:
     GCSchedulingState()
       : inHighFrequencyGCMode_(false)
     {}
 
     bool inHighFrequencyGCMode() const { return inHighFrequencyGCMode_; }
 
@@ -540,29 +540,29 @@ class GCSchedulingState
         inHighFrequencyGCMode_ =
             tunables.isDynamicHeapGrowthEnabled() && lastGCTime &&
             lastGCTime + tunables.highFrequencyThresholdUsec() > currentTime;
     }
 };
 
 template<typename F>
 struct Callback {
-    UnprotectedData<F> op;
-    UnprotectedData<void*> data;
+    ActiveThreadData<F> op;
+    ActiveThreadData<void*> data;
 
     Callback()
       : op(nullptr), data(nullptr)
     {}
     Callback(F op, void* data)
       : op(op), data(data)
     {}
 };
 
 template<typename F>
-using CallbackVector = UnprotectedData<Vector<Callback<F>, 4, SystemAllocPolicy>>;
+using CallbackVector = ActiveThreadData<Vector<Callback<F>, 4, SystemAllocPolicy>>;
 
 template <typename T, typename Iter0, typename Iter1>
 class ChainedIter
 {
     Iter0 iter0_;
     Iter1 iter1_;
 
   public:
@@ -974,17 +974,17 @@ class GCRuntime
 
   public:
     JSRuntime* const rt;
 
     /* Embedders can use this zone however they wish. */
     UnprotectedData<JS::Zone*> systemZone;
 
     // List of all zone groups (protected by the GC lock).
-    UnprotectedData<ZoneGroupVector> groups;
+    ActiveThreadData<ZoneGroupVector> groups;
 
     // The unique atoms zone, which has no zone group.
     WriteOnceData<Zone*> atomsZone;
 
   private:
     UnprotectedData<gcstats::Statistics> stats_;
   public:
     gcstats::Statistics& stats() { return stats_.ref(); }
@@ -1018,52 +1018,52 @@ class GCRuntime
     // is moved back to the emptyChunks pool and scheduled for eventual
     // release.
     UnprotectedData<ChunkPool> availableChunks_;
 
     // When all arenas in a chunk are used, it is moved to the fullChunks pool
     // so as to reduce the cost of operations on the available lists.
     UnprotectedData<ChunkPool> fullChunks_;
 
-    UnprotectedData<RootedValueMap> rootsHash;
+    ActiveThreadData<RootedValueMap> rootsHash;
 
-    UnprotectedData<size_t> maxMallocBytes;
+    ActiveThreadData<size_t> maxMallocBytes;
 
     // An incrementing id used to assign unique ids to cells that require one.
     mozilla::Atomic<uint64_t, mozilla::ReleaseAcquire> nextCellUniqueId_;
 
     /*
      * Number of the committed arenas in all GC chunks including empty chunks.
      */
     mozilla::Atomic<uint32_t, mozilla::ReleaseAcquire> numArenasFreeCommitted;
-    UnprotectedData<VerifyPreTracer*> verifyPreData;
+    ActiveThreadData<VerifyPreTracer*> verifyPreData;
 
   private:
     UnprotectedData<bool> chunkAllocationSinceLastGC;
-    UnprotectedData<int64_t> lastGCTime;
+    ActiveThreadData<int64_t> lastGCTime;
 
-    UnprotectedData<JSGCMode> mode;
+    ActiveThreadData<JSGCMode> mode;
 
     mozilla::Atomic<size_t, mozilla::ReleaseAcquire> numActiveZoneIters;
 
     /* During shutdown, the GC needs to clean up every possible object. */
-    UnprotectedData<bool> cleanUpEverything;
+    ActiveThreadData<bool> cleanUpEverything;
 
     // Gray marking must be done after all black marking is complete. However,
     // we do not have write barriers on XPConnect roots. Therefore, XPConnect
     // roots must be accumulated in the first slice of incremental GC. We
     // accumulate these roots in each zone's gcGrayRoots vector and then mark
     // them later, after black marking is complete for each compartment. This
     // accumulation can fail, but in that case we switch to non-incremental GC.
     enum class GrayBufferState {
         Unused,
         Okay,
         Failed
     };
-    UnprotectedData<GrayBufferState> grayBufferState;
+    ActiveThreadData<GrayBufferState> grayBufferState;
     bool hasBufferedGrayRoots() const { return grayBufferState == GrayBufferState::Okay; }
 
     // Clear each zone's gray buffers, but do not change the current state.
     void resetBufferedGrayRoots() const;
 
     // Reset the gray buffering state to Unused.
     void clearBufferedGrayRoots() {
         grayBufferState = GrayBufferState::Unused;
@@ -1074,138 +1074,138 @@ class GCRuntime
      * The gray bits can become invalid if UnmarkGray overflows the stack. A
      * full GC will reset this bit, since it fills in all the gray bits.
      */
     UnprotectedData<bool> grayBitsValid;
 
     mozilla::Atomic<JS::gcreason::Reason, mozilla::Relaxed> majorGCTriggerReason;
 
   public:
-    UnprotectedData<JS::gcreason::Reason> minorGCTriggerReason;
+    ActiveThreadData<JS::gcreason::Reason> minorGCTriggerReason;
 
   private:
     /* Perform full GC if rt->keepAtoms() becomes false. */
-    UnprotectedData<bool> fullGCForAtomsRequested_;
+    ActiveThreadData<bool> fullGCForAtomsRequested_;
 
     /* Incremented at the start of every minor GC. */
-    UnprotectedData<uint64_t> minorGCNumber;
+    ActiveThreadData<uint64_t> minorGCNumber;
 
     /* Incremented at the start of every major GC. */
-    UnprotectedData<uint64_t> majorGCNumber;
+    ActiveThreadData<uint64_t> majorGCNumber;
 
     /* The major GC number at which to release observed type information. */
-    UnprotectedData<uint64_t> jitReleaseNumber;
+    ActiveThreadData<uint64_t> jitReleaseNumber;
 
     /* Incremented on every GC slice. */
-    UnprotectedData<uint64_t> number;
+    ActiveThreadData<uint64_t> number;
 
     /* The number at the time of the most recent GC's first slice. */
-    UnprotectedData<uint64_t> startNumber;
+    ActiveThreadData<uint64_t> startNumber;
 
     /* Whether the currently running GC can finish in multiple slices. */
-    UnprotectedData<bool> isIncremental;
+    ActiveThreadData<bool> isIncremental;
 
     /* Whether all zones are being collected in first GC slice. */
-    UnprotectedData<bool> isFull;
+    ActiveThreadData<bool> isFull;
 
     /* Whether the heap will be compacted at the end of GC. */
-    UnprotectedData<bool> isCompacting;
+    ActiveThreadData<bool> isCompacting;
 
     /* The invocation kind of the current GC, taken from the first slice. */
-    UnprotectedData<JSGCInvocationKind> invocationKind;
+    ActiveThreadData<JSGCInvocationKind> invocationKind;
 
     /* The initial GC reason, taken from the first slice. */
-    UnprotectedData<JS::gcreason::Reason> initialReason;
+    ActiveThreadData<JS::gcreason::Reason> initialReason;
 
     /*
      * The current incremental GC phase. This is also used internally in
      * non-incremental GC.
      */
-    UnprotectedData<State> incrementalState;
+    ActiveThreadOrGCTaskData<State> incrementalState;
 
     /* Indicates that the last incremental slice exhausted the mark stack. */
-    UnprotectedData<bool> lastMarkSlice;
+    ActiveThreadData<bool> lastMarkSlice;
 
     /* Whether any sweeping will take place in the separate GC helper thread. */
-    UnprotectedData<bool> sweepOnBackgroundThread;
+    ActiveThreadData<bool> sweepOnBackgroundThread;
 
     /* Whether observed type information is being released in the current GC. */
-    UnprotectedData<bool> releaseObservedTypes;
+    ActiveThreadData<bool> releaseObservedTypes;
 
     /* Whether any black->gray edges were found during marking. */
-    UnprotectedData<BlackGrayEdgeVector> foundBlackGrayEdges;
+    ActiveThreadData<BlackGrayEdgeVector> foundBlackGrayEdges;
 
     /* Singly linked list of zones to be swept in the background. */
-    UnprotectedData<ZoneList> backgroundSweepZones;
+    ActiveThreadOrGCTaskData<ZoneList> backgroundSweepZones;
 
     /*
      * Free LIFO blocks are transferred to this allocator before being freed on
      * the background GC thread after sweeping.
      */
-    UnprotectedData<LifoAlloc> blocksToFreeAfterSweeping;
+    ActiveThreadOrGCTaskData<LifoAlloc> blocksToFreeAfterSweeping;
 
   private:
     /* Index of current zone group (for stats). */
-    UnprotectedData<unsigned> zoneGroupIndex;
+    ActiveThreadData<unsigned> zoneGroupIndex;
 
     /*
      * Incremental sweep state.
      */
-    UnprotectedData<JS::Zone*> zoneGroups;
-    UnprotectedData<JS::Zone*> currentZoneGroup;
-    UnprotectedData<bool> sweepingTypes;
-    UnprotectedData<unsigned> finalizePhase;
-    UnprotectedData<JS::Zone*> sweepZone;
-    UnprotectedData<AllocKind> sweepKind;
-    UnprotectedData<bool> abortSweepAfterCurrentGroup;
+    ActiveThreadData<JS::Zone*> zoneGroups;
+    ActiveThreadOrGCTaskData<JS::Zone*> currentZoneGroup;
+    ActiveThreadData<bool> sweepingTypes;
+    ActiveThreadData<unsigned> finalizePhase;
+    ActiveThreadData<JS::Zone*> sweepZone;
+    ActiveThreadData<AllocKind> sweepKind;
+    ActiveThreadData<bool> abortSweepAfterCurrentGroup;
 
     /*
      * Concurrent sweep infrastructure.
      */
     void startTask(GCParallelTask& task, gcstats::Phase phase, AutoLockHelperThreadState& locked);
     void joinTask(GCParallelTask& task, gcstats::Phase phase, AutoLockHelperThreadState& locked);
 
     /*
      * List head of arenas allocated during the sweep phase.
      */
-    UnprotectedData<Arena*> arenasAllocatedDuringSweep;
+    ActiveThreadData<Arena*> arenasAllocatedDuringSweep;
 
     /*
      * Incremental compacting state.
      */
-    UnprotectedData<bool> startedCompacting;
-    UnprotectedData<ZoneList> zonesToMaybeCompact;
-    UnprotectedData<Arena*> relocatedArenasToRelease;
+    ActiveThreadData<bool> startedCompacting;
+    ActiveThreadData<ZoneList> zonesToMaybeCompact;
+    ActiveThreadData<Arena*> relocatedArenasToRelease;
 
 #ifdef JS_GC_ZEAL
-    UnprotectedData<MarkingValidator*> markingValidator;
+    ActiveThreadData<MarkingValidator*> markingValidator;
 #endif
 
     /*
      * Indicates that a GC slice has taken place in the middle of an animation
      * frame, rather than at the beginning. In this case, the next slice will be
      * delayed so that we don't get back-to-back slices.
      */
-    UnprotectedData<bool> interFrameGC;
+    ActiveThreadData<bool> interFrameGC;
 
     /* Default budget for incremental GC slice. See js/SliceBudget.h. */
-    UnprotectedData<int64_t> defaultTimeBudget_;
+    ActiveThreadData<int64_t> defaultTimeBudget_;
 
     /*
      * We disable incremental GC if we encounter a Class with a trace hook
      * that does not implement write barriers.
      */
-    UnprotectedData<bool> incrementalAllowed;
+    ActiveThreadData<bool> incrementalAllowed;
 
     /*
      * Whether compacting GC can is enabled globally.
      */
-    UnprotectedData<bool> compactingEnabled;
+    ActiveThreadData<bool> compactingEnabled;
 
-    UnprotectedData<bool> poked;
+    ActiveThreadData<bool> poked;
 
     /*
      * These options control the zealousness of the GC. At every allocation,
      * nextScheduled is decremented. When it reaches zero we do a full GC.
      *
      * At this point, if zeal_ is one of the types that trigger periodic
      * collection, then nextScheduled is reset to the value of zealFrequency.
      * Otherwise, no additional GCs take place.
@@ -1222,26 +1222,26 @@ class GCRuntime
      * in jsgc.cpp for more information about this.
      *
      * zeal_ values from 8 to 10 periodically run different types of
      * incremental GC.
      *
      * zeal_ value 14 performs periodic shrinking collections.
      */
 #ifdef JS_GC_ZEAL
-    UnprotectedData<uint32_t> zealModeBits;
-    UnprotectedData<int> zealFrequency;
-    UnprotectedData<int> nextScheduled;
-    UnprotectedData<bool> deterministicOnly;
-    UnprotectedData<int> incrementalLimit;
+    ActiveThreadData<uint32_t> zealModeBits;
+    ActiveThreadData<int> zealFrequency;
+    ActiveThreadData<int> nextScheduled;
+    ActiveThreadData<bool> deterministicOnly;
+    ActiveThreadData<int> incrementalLimit;
 
-    UnprotectedData<Vector<JSObject*, 0, SystemAllocPolicy>> selectedForMarking;
+    ActiveThreadData<Vector<JSObject*, 0, SystemAllocPolicy>> selectedForMarking;
 #endif
 
-    UnprotectedData<bool> fullCompartmentChecks;
+    ActiveThreadData<bool> fullCompartmentChecks;
 
     Callback<JSGCCallback> gcCallback;
     Callback<JS::DoCycleCollectionCallback> gcDoCycleCollectionCallback;
     Callback<JSObjectsTenuredCallback> tenuredCallback;
     CallbackVector<JSFinalizeCallback> finalizeCallbacks;
     CallbackVector<JSWeakPointerZoneGroupCallback> updateWeakPointerZoneGroupCallbacks;
     CallbackVector<JSWeakPointerCompartmentCallback> updateWeakPointerCompartmentCallbacks;
 
@@ -1262,36 +1262,36 @@ class GCRuntime
      * tracing through black roots and the other is for tracing through gray
      * roots. The black/gray distinction is only relevant to the cycle
      * collector.
      */
     CallbackVector<JSTraceDataOp> blackRootTracers;
     Callback<JSTraceDataOp> grayRootTracer;
 
     /* Always preserve JIT code during GCs, for testing. */
-    UnprotectedData<bool> alwaysPreserveCode;
+    ActiveThreadData<bool> alwaysPreserveCode;
 
 #ifdef DEBUG
-    UnprotectedData<bool> arenasEmptyAtShutdown;
+    ActiveThreadData<bool> arenasEmptyAtShutdown;
 #endif
 
     /* Synchronize GC heap access among GC helper threads and main threads. */
     friend class js::AutoLockGC;
     js::Mutex lock;
 
     BackgroundAllocTask allocTask;
     BackgroundDecommitTask decommitTask;
 
     GCHelperState helperState;
 
     /*
      * During incremental sweeping, this field temporarily holds the arenas of
      * the current AllocKind being swept in order of increasing free space.
      */
-    UnprotectedData<SortedArenaList> incrementalSweepList;
+    ActiveThreadData<SortedArenaList> incrementalSweepList;
 
     friend class js::GCHelperState;
     friend class MarkingValidator;
     friend class AutoTraceSession;
     friend class AutoEnterIteration;
 };
 
 /* Prevent compartments and zones from being collected during iteration. */

--- a/js/src/gc/Marking.h
+++ b/js/src/gc/Marking.h
@@ -52,23 +52,23 @@ static const size_t INCREMENTAL_MARK_STA
  * stack list with the pointer to stack top in GCMarker::unmarkedArenaStackTop.
  * GCMarker::delayMarkingChildren adds arenas to the stack as necessary while
  * markDelayedChildren pops the arenas from the stack until it empties.
  */
 class MarkStack
 {
     friend class GCMarker;
 
-    UnprotectedData<uintptr_t*> stack_;
-    UnprotectedData<uintptr_t*> tos_;
-    UnprotectedData<uintptr_t*> end_;
+    ActiveThreadData<uintptr_t*> stack_;
+    ActiveThreadData<uintptr_t*> tos_;
+    ActiveThreadData<uintptr_t*> end_;
 
     // The capacity we start with and reset() to.
-    UnprotectedData<size_t> baseCapacity_;
-    UnprotectedData<size_t> maxCapacity_;
+    ActiveThreadData<size_t> baseCapacity_;
+    ActiveThreadData<size_t> maxCapacity_;
 
   public:
     explicit MarkStack(size_t maxCapacity)
       : stack_(nullptr),
         tos_(nullptr),
         end_(nullptr),
         baseCapacity_(0),
         maxCapacity_(maxCapacity)
@@ -331,39 +331,39 @@ class GCMarker : public JSTracer
     MOZ_MUST_USE bool restoreValueArray(JSObject* obj, void** vpp, void** endp);
     void saveValueRanges();
     inline void processMarkStackTop(SliceBudget& budget);
 
     /* The mark stack. Pointers in this stack are "gray" in the GC sense. */
     MarkStack stack;
 
     /* The color is only applied to objects and functions. */
-    UnprotectedData<uint32_t> color;
+    ActiveThreadData<uint32_t> color;
 
     /* Pointer to the top of the stack of arenas we are delaying marking on. */
-    UnprotectedData<js::gc::Arena*> unmarkedArenaStackTop;
+    ActiveThreadData<js::gc::Arena*> unmarkedArenaStackTop;
 
     /*
      * If the weakKeys table OOMs, disable the linear algorithm and fall back
      * to iterating until the next GC.
      */
-    UnprotectedData<bool> linearWeakMarkingDisabled_;
+    ActiveThreadData<bool> linearWeakMarkingDisabled_;
 
 #ifdef DEBUG
     /* Count of arenas that are currently in the stack. */
-    UnprotectedData<size_t> markLaterArenas;
+    ActiveThreadData<size_t> markLaterArenas;
 
     /* Assert that start and stop are called with correct ordering. */
-    UnprotectedData<bool> started;
+    ActiveThreadData<bool> started;
 
     /*
      * If this is true, all marked objects must belong to a compartment being
      * GCed. This is used to look for compartment bugs.
      */
-    UnprotectedData<bool> strictCompartmentChecking;
+    ActiveThreadData<bool> strictCompartmentChecking;
 #endif // DEBUG
 };
 
 #ifdef DEBUG
 // Return true if this trace is happening on behalf of gray buffering during
 // the marking phase of incremental GC.
 bool
 IsBufferGrayRootsTracer(JSTracer* trc);