Add m-esr52 at 52.6.0

1 files changed, 2455 insertions, 0 deletions

diff --git a/dom/xhr/XMLHttpRequestWorker.cpp b/dom/xhr/XMLHttpRequestWorker.cpp
new file mode 100644
index 000000000..f61383baf
--- /dev/null
+++ b/dom/xhr/XMLHttpRequestWorker.cpp
@@ -0,0 +1,2455 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "XMLHttpRequestWorker.h"
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMEventListener.h"
+#include "nsIRunnable.h"
+#include "nsIXMLHttpRequest.h"
+#include "nsIXPConnect.h"
+
+#include "jsfriendapi.h"
+#include "js/TracingAPI.h"
+#include "js/GCPolicyAPI.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FormData.h"
+#include "mozilla/dom/ProgressEvent.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "mozilla/dom/URLSearchParams.h"
+#include "mozilla/Telemetry.h"
+#include "nsComponentManagerUtils.h"
+#include "nsContentUtils.h"
+#include "nsJSUtils.h"
+#include "nsThreadUtils.h"
+#include "nsVariant.h"
+
+#include "RuntimeService.h"
+#include "WorkerScope.h"
+#include "WorkerPrivate.h"
+#include "WorkerRunnable.h"
+#include "XMLHttpRequestUpload.h"
+
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+namespace dom {
+
+using namespace workers;
+
+/* static */ void
+XMLHttpRequestWorker::StateData::trace(JSTracer *aTrc)
+{
+  JS::TraceEdge(aTrc, &mResponse, "XMLHttpRequestWorker::StateData::mResponse");
+}
+
+/**
+ *  XMLHttpRequest in workers
+ *
+ *  XHR in workers is implemented by proxying calls/events/etc between the
+ *  worker thread and an XMLHttpRequest on the main thread.  The glue
+ *  object here is the Proxy, which lives on both threads.  All other objects
+ *  live on either the main thread (the XMLHttpRequest) or the worker thread
+ *  (the worker and XHR private objects).
+ *
+ *  The main thread XHR is always operated in async mode, even for sync XHR
+ *  in workers.  Calls made on the worker thread are proxied to the main thread
+ *  synchronously (meaning the worker thread is blocked until the call
+ *  returns).  Each proxied call spins up a sync queue, which captures any
+ *  synchronously dispatched events and ensures that they run synchronously
+ *  on the worker as well.  Asynchronously dispatched events are posted to the
+ *  worker thread to run asynchronously.  Some of the XHR state is mirrored on
+ *  the worker thread to avoid needing a cross-thread call on every property
+ *  access.
+ *
+ *  The XHR private is stored in the private slot of the XHR JSObject on the
+ *  worker thread.  It is destroyed when that JSObject is GCd.  The private
+ *  roots its JSObject while network activity is in progress.  It also
+ *  adds itself as a feature to the worker to give itself a chance to clean up
+ *  if the worker goes away during an XHR call.  It is important that the
+ *  rooting and feature registration (collectively called pinning) happens at
+ *  the proper times.  If we pin for too long we can cause memory leaks or even
+ *  shutdown hangs.  If we don't pin for long enough we introduce a GC hazard.
+ *
+ *  The XHR is pinned from the time Send is called to roughly the time loadend
+ *  is received.  There are some complications involved with Abort and XHR
+ *  reuse.  We maintain a counter on the main thread of how many times Send was
+ *  called on this XHR, and we decrement the counter every time we receive a
+ *  loadend event.  When the counter reaches zero we dispatch a runnable to the
+ *  worker thread to unpin the XHR.  We only decrement the counter if the 
+ *  dispatch was successful, because the worker may no longer be accepting
+ *  regular runnables.  In the event that we reach Proxy::Teardown and there
+ *  the outstanding Send count is still non-zero, we dispatch a control
+ *  runnable which is guaranteed to run.
+ *
+ *  NB: Some of this could probably be simplified now that we have the
+ *  inner/outer channel ids.
+ */
+
+class Proxy final : public nsIDOMEventListener
+{
+public:
+  // Read on multiple threads.
+  WorkerPrivate* mWorkerPrivate;
+  XMLHttpRequestWorker* mXMLHttpRequestPrivate;
+
+  // XHR Params:
+  bool mMozAnon;
+  bool mMozSystem;
+
+  // Only touched on the main thread.
+  RefPtr<XMLHttpRequestMainThread> mXHR;
+  nsCOMPtr<nsIXMLHttpRequestUpload> mXHRUpload;
+  nsCOMPtr<nsIEventTarget> mSyncLoopTarget;
+  nsCOMPtr<nsIEventTarget> mSyncEventResponseTarget;
+  uint32_t mInnerEventStreamId;
+  uint32_t mInnerChannelId;
+  uint32_t mOutstandingSendCount;
+
+  // Only touched on the worker thread.
+  uint32_t mOuterEventStreamId;
+  uint32_t mOuterChannelId;
+  uint32_t mOpenCount;
+  uint64_t mLastLoaded;
+  uint64_t mLastTotal;
+  uint64_t mLastUploadLoaded;
+  uint64_t mLastUploadTotal;
+  bool mIsSyncXHR;
+  bool mLastLengthComputable;
+  bool mLastUploadLengthComputable;
+  bool mSeenLoadStart;
+  bool mSeenUploadLoadStart;
+
+  // Only touched on the main thread.
+  bool mUploadEventListenersAttached;
+  bool mMainThreadSeenLoadStart;
+  bool mInOpen;
+  bool mArrayBufferResponseWasTransferred;
+
+public:
+  Proxy(XMLHttpRequestWorker* aXHRPrivate, bool aMozAnon, bool aMozSystem)
+  : mWorkerPrivate(nullptr), mXMLHttpRequestPrivate(aXHRPrivate),
+    mMozAnon(aMozAnon), mMozSystem(aMozSystem),
+    mInnerEventStreamId(0), mInnerChannelId(0), mOutstandingSendCount(0),
+    mOuterEventStreamId(0), mOuterChannelId(0), mOpenCount(0), mLastLoaded(0),
+    mLastTotal(0), mLastUploadLoaded(0), mLastUploadTotal(0), mIsSyncXHR(false),
+    mLastLengthComputable(false), mLastUploadLengthComputable(false),
+    mSeenLoadStart(false), mSeenUploadLoadStart(false),
+    mUploadEventListenersAttached(false), mMainThreadSeenLoadStart(false),
+    mInOpen(false), mArrayBufferResponseWasTransferred(false)
+  { }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  bool
+  Init();
+
+  void
+  Teardown(bool aSendUnpin);
+
+  bool
+  AddRemoveEventListeners(bool aUpload, bool aAdd);
+
+  void
+  Reset()
+  {
+    AssertIsOnMainThread();
+
+    if (mUploadEventListenersAttached) {
+      AddRemoveEventListeners(true, false);
+    }
+  }
+
+  already_AddRefed<nsIEventTarget>
+  GetEventTarget()
+  {
+    AssertIsOnMainThread();
+
+    nsCOMPtr<nsIEventTarget> target = mSyncEventResponseTarget ?
+                                      mSyncEventResponseTarget :
+                                      mSyncLoopTarget;
+    return target.forget();
+  }
+
+private:
+  ~Proxy()
+  {
+    MOZ_ASSERT(!mXHR);
+    MOZ_ASSERT(!mXHRUpload);
+    MOZ_ASSERT(!mOutstandingSendCount);
+  }
+};
+
+class WorkerThreadProxySyncRunnable : public WorkerMainThreadRunnable
+{
+protected:
+  RefPtr<Proxy> mProxy;
+
+private:
+  // mErrorCode is set on the main thread by MainThreadRun and it's used to at
+  // the end of the Dispatch() to return the error code.
+  nsresult mErrorCode;
+
+public:
+  WorkerThreadProxySyncRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy)
+  : WorkerMainThreadRunnable(aWorkerPrivate, NS_LITERAL_CSTRING("XHR"))
+  , mProxy(aProxy)
+  , mErrorCode(NS_OK)
+  {
+    MOZ_ASSERT(aWorkerPrivate);
+    MOZ_ASSERT(aProxy);
+    aWorkerPrivate->AssertIsOnWorkerThread();
+  }
+
+  void
+  Dispatch(ErrorResult& aRv)
+  {
+    WorkerMainThreadRunnable::Dispatch(aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return;
+    }
+
+    if (NS_FAILED(mErrorCode)) {
+      aRv.Throw(mErrorCode);
+    }
+  }
+
+protected:
+  virtual ~WorkerThreadProxySyncRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) = 0;
+
+private:
+  virtual bool MainThreadRun() override;
+};
+
+class SendRunnable final
+  : public WorkerThreadProxySyncRunnable
+  , public StructuredCloneHolder
+{
+  nsString mStringBody;
+  nsCOMPtr<nsIEventTarget> mSyncLoopTarget;
+  bool mHasUploadListeners;
+
+public:
+  SendRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+               const nsAString& aStringBody)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy)
+  , StructuredCloneHolder(CloningSupported, TransferringNotSupported,
+                          StructuredCloneScope::SameProcessDifferentThread)
+  , mStringBody(aStringBody)
+  , mHasUploadListeners(false)
+  {
+  }
+
+  void SetHaveUploadListeners(bool aHasUploadListeners)
+  {
+    mHasUploadListeners = aHasUploadListeners;
+  }
+
+  void SetSyncLoopTarget(nsIEventTarget* aSyncLoopTarget)
+  {
+    mSyncLoopTarget = aSyncLoopTarget;
+  }
+
+private:
+  ~SendRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override;
+};
+
+namespace {
+
+enum
+{
+  STRING_abort = 0,
+  STRING_error,
+  STRING_load,
+  STRING_loadstart,
+  STRING_progress,
+  STRING_timeout,
+  STRING_readystatechange,
+  STRING_loadend,
+
+  STRING_COUNT,
+
+  STRING_LAST_XHR = STRING_loadend,
+  STRING_LAST_EVENTTARGET = STRING_timeout
+};
+
+static_assert(STRING_LAST_XHR >= STRING_LAST_EVENTTARGET, "Bad string setup!");
+static_assert(STRING_LAST_XHR == STRING_COUNT - 1, "Bad string setup!");
+
+const char* const sEventStrings[] = {
+  // nsIXMLHttpRequestEventTarget event types, supported by both XHR and Upload.
+  "abort",
+  "error",
+  "load",
+  "loadstart",
+  "progress",
+  "timeout",
+
+  // nsIXMLHttpRequest event types, supported only by XHR.
+  "readystatechange",
+  "loadend",
+};
+
+static_assert(MOZ_ARRAY_LENGTH(sEventStrings) == STRING_COUNT,
+              "Bad string count!");
+
+class MainThreadProxyRunnable : public MainThreadWorkerSyncRunnable
+{
+protected:
+  RefPtr<Proxy> mProxy;
+
+  MainThreadProxyRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy)
+  : MainThreadWorkerSyncRunnable(aWorkerPrivate, aProxy->GetEventTarget()),
+    mProxy(aProxy)
+  {
+    MOZ_ASSERT(aProxy);
+  }
+
+  virtual ~MainThreadProxyRunnable()
+  { }
+};
+
+class XHRUnpinRunnable final : public MainThreadWorkerControlRunnable
+{
+  XMLHttpRequestWorker* mXMLHttpRequestPrivate;
+
+public:
+  XHRUnpinRunnable(WorkerPrivate* aWorkerPrivate,
+                   XMLHttpRequestWorker* aXHRPrivate)
+  : MainThreadWorkerControlRunnable(aWorkerPrivate),
+    mXMLHttpRequestPrivate(aXHRPrivate)
+  {
+    MOZ_ASSERT(aXHRPrivate);
+  }
+
+private:
+  ~XHRUnpinRunnable()
+  { }
+
+  bool
+  WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
+  {
+    if (mXMLHttpRequestPrivate->SendInProgress()) {
+      mXMLHttpRequestPrivate->Unpin();
+    }
+
+    return true;
+  }
+};
+
+class AsyncTeardownRunnable final : public Runnable
+{
+  RefPtr<Proxy> mProxy;
+
+public:
+  explicit AsyncTeardownRunnable(Proxy* aProxy)
+  : mProxy(aProxy)
+  {
+    MOZ_ASSERT(aProxy);
+  }
+
+private:
+  ~AsyncTeardownRunnable()
+  { }
+
+  NS_IMETHOD
+  Run() override
+  {
+    AssertIsOnMainThread();
+
+    // This means the XHR was GC'd, so we can't be pinned, and we don't need to
+    // try to unpin.
+    mProxy->Teardown(/* aSendUnpin */ false);
+    mProxy = nullptr;
+
+    return NS_OK;
+  }
+};
+
+class LoadStartDetectionRunnable final : public Runnable,
+                                         public nsIDOMEventListener
+{
+  WorkerPrivate* mWorkerPrivate;
+  RefPtr<Proxy> mProxy;
+  RefPtr<XMLHttpRequest> mXHR;
+  XMLHttpRequestWorker* mXMLHttpRequestPrivate;
+  nsString mEventType;
+  uint32_t mChannelId;
+  bool mReceivedLoadStart;
+
+  class ProxyCompleteRunnable final : public MainThreadProxyRunnable
+  {
+    XMLHttpRequestWorker* mXMLHttpRequestPrivate;
+    uint32_t mChannelId;
+
+  public:
+    ProxyCompleteRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                          XMLHttpRequestWorker* aXHRPrivate, uint32_t aChannelId)
+    : MainThreadProxyRunnable(aWorkerPrivate, aProxy),
+      mXMLHttpRequestPrivate(aXHRPrivate), mChannelId(aChannelId)
+    { }
+
+  private:
+    ~ProxyCompleteRunnable()
+    { }
+
+    virtual bool
+    WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+    {
+      if (mChannelId != mProxy->mOuterChannelId) {
+        // Threads raced, this event is now obsolete.
+        return true;
+      }
+
+      if (mSyncLoopTarget) {
+        aWorkerPrivate->StopSyncLoop(mSyncLoopTarget, true);
+      }
+
+      if (mXMLHttpRequestPrivate->SendInProgress()) {
+        mXMLHttpRequestPrivate->Unpin();
+      }
+
+      return true;
+    }
+
+    nsresult
+    Cancel() override
+    {
+      // This must run!
+      nsresult rv = MainThreadProxyRunnable::Cancel();
+      nsresult rv2 = Run();
+      return NS_FAILED(rv) ? rv : rv2;
+    }
+  };
+
+public:
+  LoadStartDetectionRunnable(Proxy* aProxy, XMLHttpRequestWorker* aXHRPrivate)
+  : mWorkerPrivate(aProxy->mWorkerPrivate), mProxy(aProxy), mXHR(aProxy->mXHR),
+    mXMLHttpRequestPrivate(aXHRPrivate), mChannelId(mProxy->mInnerChannelId),
+    mReceivedLoadStart(false)
+  {
+    AssertIsOnMainThread();
+    mEventType.AssignWithConversion(sEventStrings[STRING_loadstart]);
+  }
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIRUNNABLE
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  bool
+  RegisterAndDispatch()
+  {
+    AssertIsOnMainThread();
+
+    if (NS_FAILED(mXHR->AddEventListener(mEventType, this, false, false, 2))) {
+      NS_WARNING("Failed to add event listener!");
+      return false;
+    }
+
+    return NS_SUCCEEDED(NS_DispatchToCurrentThread(this));
+  }
+
+private:
+  ~LoadStartDetectionRunnable()
+  {
+    AssertIsOnMainThread();
+    }
+};
+
+class EventRunnable final : public MainThreadProxyRunnable
+                          , public StructuredCloneHolder
+{
+  nsString mType;
+  nsString mResponseType;
+  JS::Heap<JS::Value> mResponse;
+  XMLHttpRequestStringSnapshot mResponseText;
+  nsString mResponseURL;
+  nsCString mStatusText;
+  uint64_t mLoaded;
+  uint64_t mTotal;
+  uint32_t mEventStreamId;
+  uint32_t mStatus;
+  uint16_t mReadyState;
+  bool mUploadEvent;
+  bool mProgressEvent;
+  bool mLengthComputable;
+  bool mUseCachedArrayBufferResponse;
+  nsresult mResponseTextResult;
+  nsresult mStatusResult;
+  nsresult mResponseResult;
+  // mScopeObj is used in PreDispatch only.  We init it in our constructor, and
+  // reset() in PreDispatch, to ensure that it's not still linked into the
+  // runtime once we go off-thread.
+  JS::PersistentRooted<JSObject*> mScopeObj;
+
+public:
+  EventRunnable(Proxy* aProxy, bool aUploadEvent, const nsString& aType,
+                bool aLengthComputable, uint64_t aLoaded, uint64_t aTotal,
+                JS::Handle<JSObject*> aScopeObj)
+  : MainThreadProxyRunnable(aProxy->mWorkerPrivate, aProxy),
+    StructuredCloneHolder(CloningSupported, TransferringNotSupported,
+                          StructuredCloneScope::SameProcessDifferentThread),
+    mType(aType), mResponse(JS::UndefinedValue()), mLoaded(aLoaded),
+    mTotal(aTotal), mEventStreamId(aProxy->mInnerEventStreamId), mStatus(0),
+    mReadyState(0), mUploadEvent(aUploadEvent), mProgressEvent(true),
+    mLengthComputable(aLengthComputable), mUseCachedArrayBufferResponse(false),
+    mResponseTextResult(NS_OK), mStatusResult(NS_OK), mResponseResult(NS_OK),
+    mScopeObj(RootingCx(), aScopeObj)
+  { }
+
+  EventRunnable(Proxy* aProxy, bool aUploadEvent, const nsString& aType,
+                JS::Handle<JSObject*> aScopeObj)
+  : MainThreadProxyRunnable(aProxy->mWorkerPrivate, aProxy),
+    StructuredCloneHolder(CloningSupported, TransferringNotSupported,
+                          StructuredCloneScope::SameProcessDifferentThread),
+    mType(aType), mResponse(JS::UndefinedValue()), mLoaded(0), mTotal(0),
+    mEventStreamId(aProxy->mInnerEventStreamId), mStatus(0), mReadyState(0),
+    mUploadEvent(aUploadEvent), mProgressEvent(false), mLengthComputable(0),
+    mUseCachedArrayBufferResponse(false), mResponseTextResult(NS_OK),
+    mStatusResult(NS_OK), mResponseResult(NS_OK),
+    mScopeObj(RootingCx(), aScopeObj)
+  { }
+
+private:
+  ~EventRunnable()
+  { }
+
+  virtual bool
+  PreDispatch(WorkerPrivate* /* unused */) override final;
+
+  virtual bool
+  WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override;
+};
+
+class SyncTeardownRunnable final : public WorkerThreadProxySyncRunnable
+{
+public:
+  SyncTeardownRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy)
+  { }
+
+private:
+  ~SyncTeardownRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->Teardown(/* aSendUnpin */ true);
+    MOZ_ASSERT(!mProxy->mSyncLoopTarget);
+  }
+};
+
+class SetBackgroundRequestRunnable final :
+  public WorkerThreadProxySyncRunnable
+{
+  bool mValue;
+
+public:
+  SetBackgroundRequestRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                               bool aValue)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy)
+  , mValue(aValue)
+  { }
+
+private:
+  ~SetBackgroundRequestRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->SetMozBackgroundRequest(mValue, aRv);
+  }
+};
+
+class SetWithCredentialsRunnable final :
+  public WorkerThreadProxySyncRunnable
+{
+  bool mValue;
+
+public:
+  SetWithCredentialsRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                             bool aValue)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy)
+  , mValue(aValue)
+  { }
+
+private:
+  ~SetWithCredentialsRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->SetWithCredentials(mValue, aRv);
+  }
+};
+
+class SetResponseTypeRunnable final : public WorkerThreadProxySyncRunnable
+{
+  XMLHttpRequestResponseType mResponseType;
+
+public:
+  SetResponseTypeRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                          XMLHttpRequestResponseType aResponseType)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mResponseType(aResponseType)
+  { }
+
+  XMLHttpRequestResponseType
+  ResponseType()
+  {
+    return mResponseType;
+  }
+
+private:
+  ~SetResponseTypeRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->SetResponseType(mResponseType, aRv);
+    if (!aRv.Failed()) {
+      mResponseType = mProxy->mXHR->ResponseType();
+    }
+  }
+};
+
+class SetTimeoutRunnable final : public WorkerThreadProxySyncRunnable
+{
+  uint32_t mTimeout;
+
+public:
+  SetTimeoutRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                     uint32_t aTimeout)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mTimeout(aTimeout)
+  { }
+
+private:
+  ~SetTimeoutRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->SetTimeout(mTimeout, aRv);
+  }
+};
+
+class AbortRunnable final : public WorkerThreadProxySyncRunnable
+{
+public:
+  AbortRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy)
+  { }
+
+private:
+  ~AbortRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override;
+};
+
+class GetAllResponseHeadersRunnable final :
+  public WorkerThreadProxySyncRunnable
+{
+  nsCString& mResponseHeaders;
+
+public:
+  GetAllResponseHeadersRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                                nsCString& aResponseHeaders)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mResponseHeaders(aResponseHeaders)
+  { }
+
+private:
+  ~GetAllResponseHeadersRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->GetAllResponseHeaders(mResponseHeaders, aRv);
+  }
+};
+
+class GetResponseHeaderRunnable final : public WorkerThreadProxySyncRunnable
+{
+  const nsCString mHeader;
+  nsCString& mValue;
+
+public:
+  GetResponseHeaderRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                            const nsACString& aHeader, nsCString& aValue)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mHeader(aHeader),
+    mValue(aValue)
+  { }
+
+private:
+  ~GetResponseHeaderRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->GetResponseHeader(mHeader, mValue, aRv);
+  }
+};
+
+class OpenRunnable final : public WorkerThreadProxySyncRunnable
+{
+  nsCString mMethod;
+  nsString mURL;
+  Optional<nsAString> mUser;
+  nsString mUserStr;
+  Optional<nsAString> mPassword;
+  nsString mPasswordStr;
+  bool mBackgroundRequest;
+  bool mWithCredentials;
+  uint32_t mTimeout;
+  XMLHttpRequestResponseType mResponseType;
+
+public:
+  OpenRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+               const nsACString& aMethod, const nsAString& aURL,
+               const Optional<nsAString>& aUser,
+               const Optional<nsAString>& aPassword,
+               bool aBackgroundRequest, bool aWithCredentials,
+               uint32_t aTimeout, XMLHttpRequestResponseType aResponseType)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mMethod(aMethod),
+    mURL(aURL), mBackgroundRequest(aBackgroundRequest),
+    mWithCredentials(aWithCredentials), mTimeout(aTimeout),
+    mResponseType(aResponseType)
+  {
+    if (aUser.WasPassed()) {
+      mUserStr = aUser.Value();
+      mUser = &mUserStr;
+    }
+    if (aPassword.WasPassed()) {
+      mPasswordStr = aPassword.Value();
+      mPassword = &mPasswordStr;
+    }
+  }
+
+private:
+  ~OpenRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    WorkerPrivate* oldWorker = mProxy->mWorkerPrivate;
+    mProxy->mWorkerPrivate = mWorkerPrivate;
+
+    aRv = MainThreadRunInternal();
+
+    mProxy->mWorkerPrivate = oldWorker;
+  }
+
+  nsresult
+  MainThreadRunInternal();
+};
+
+class SetRequestHeaderRunnable final : public WorkerThreadProxySyncRunnable
+{
+  nsCString mHeader;
+  nsCString mValue;
+
+public:
+  SetRequestHeaderRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                           const nsACString& aHeader, const nsACString& aValue)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mHeader(aHeader),
+    mValue(aValue)
+  { }
+
+private:
+  ~SetRequestHeaderRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->SetRequestHeader(mHeader, mValue, aRv);
+  }
+};
+
+class OverrideMimeTypeRunnable final : public WorkerThreadProxySyncRunnable
+{
+  nsString mMimeType;
+
+public:
+  OverrideMimeTypeRunnable(WorkerPrivate* aWorkerPrivate, Proxy* aProxy,
+                           const nsAString& aMimeType)
+  : WorkerThreadProxySyncRunnable(aWorkerPrivate, aProxy),
+    mMimeType(aMimeType)
+  { }
+
+private:
+  ~OverrideMimeTypeRunnable()
+  { }
+
+  virtual void
+  RunOnMainThread(ErrorResult& aRv) override
+  {
+    mProxy->mXHR->OverrideMimeType(mMimeType, aRv);
+  }
+};
+
+class AutoUnpinXHR
+{
+  XMLHttpRequestWorker* mXMLHttpRequestPrivate;
+
+public:
+  explicit AutoUnpinXHR(XMLHttpRequestWorker* aXMLHttpRequestPrivate)
+  : mXMLHttpRequestPrivate(aXMLHttpRequestPrivate)
+  {
+    MOZ_ASSERT(aXMLHttpRequestPrivate);
+  }
+
+  ~AutoUnpinXHR()
+  {
+    if (mXMLHttpRequestPrivate) {
+      mXMLHttpRequestPrivate->Unpin();
+    }
+  }
+
+  void Clear()
+  {
+    mXMLHttpRequestPrivate = nullptr;
+  }
+};
+
+} // namespace
+
+bool
+Proxy::Init()
+{
+  AssertIsOnMainThread();
+  MOZ_ASSERT(mWorkerPrivate);
+
+  if (mXHR) {
+    return true;
+  }
+
+  nsPIDOMWindowInner* ownerWindow = mWorkerPrivate->GetWindow();
+  if (ownerWindow && !ownerWindow->IsCurrentInnerWindow()) {
+    NS_WARNING("Window has navigated, cannot create XHR here.");
+    return false;
+  }
+
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(ownerWindow);
+
+  mXHR = new XMLHttpRequestMainThread();
+  mXHR->Construct(mWorkerPrivate->GetPrincipal(), global,
+                  mWorkerPrivate->GetBaseURI(),
+                  mWorkerPrivate->GetLoadGroup());
+
+  mXHR->SetParameters(mMozAnon, mMozSystem);
+
+  ErrorResult rv;
+  mXHRUpload = mXHR->GetUpload(rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    mXHR = nullptr;
+    return false;
+  }
+
+  if (!AddRemoveEventListeners(false, true)) {
+    mXHR = nullptr;
+    mXHRUpload = nullptr;
+    return false;
+  }
+
+  return true;
+}
+
+void
+Proxy::Teardown(bool aSendUnpin)
+{
+  AssertIsOnMainThread();
+
+  if (mXHR) {
+    Reset();
+
+    // NB: We are intentionally dropping events coming from xhr.abort on the
+    // floor.
+    AddRemoveEventListeners(false, false);
+
+    ErrorResult rv;
+    mXHR->Abort(rv);
+    if (NS_WARN_IF(rv.Failed())) {
+      rv.SuppressException();
+    }
+
+    if (mOutstandingSendCount) {
+      if (aSendUnpin) {
+        RefPtr<XHRUnpinRunnable> runnable =
+          new XHRUnpinRunnable(mWorkerPrivate, mXMLHttpRequestPrivate);
+        if (!runnable->Dispatch()) {
+          NS_RUNTIMEABORT("We're going to hang at shutdown anyways.");
+        }
+      }
+
+      if (mSyncLoopTarget) {
+        // We have an unclosed sync loop.  Fix that now.
+        RefPtr<MainThreadStopSyncLoopRunnable> runnable =
+          new MainThreadStopSyncLoopRunnable(mWorkerPrivate,
+                                             mSyncLoopTarget.forget(),
+                                             false);
+        if (!runnable->Dispatch()) {
+          NS_RUNTIMEABORT("We're going to hang at shutdown anyways.");
+        }
+      }
+
+      mOutstandingSendCount = 0;
+    }
+
+    mWorkerPrivate = nullptr;
+    mXHRUpload = nullptr;
+    mXHR = nullptr;
+  }
+
+  MOZ_ASSERT(!mWorkerPrivate);
+  MOZ_ASSERT(!mSyncLoopTarget);
+}
+
+bool
+Proxy::AddRemoveEventListeners(bool aUpload, bool aAdd)
+{
+  AssertIsOnMainThread();
+
+  NS_ASSERTION(!aUpload ||
+               (mUploadEventListenersAttached && !aAdd) ||
+               (!mUploadEventListenersAttached && aAdd),
+               "Messed up logic for upload listeners!");
+
+  nsCOMPtr<nsIDOMEventTarget> target =
+    aUpload ?
+    do_QueryInterface(mXHRUpload) :
+    do_QueryInterface(static_cast<nsIXMLHttpRequest*>(mXHR.get()));
+  NS_ASSERTION(target, "This should never fail!");
+
+  uint32_t lastEventType = aUpload ? STRING_LAST_EVENTTARGET : STRING_LAST_XHR;
+
+  nsAutoString eventType;
+  for (uint32_t index = 0; index <= lastEventType; index++) {
+    eventType = NS_ConvertASCIItoUTF16(sEventStrings[index]);
+    if (aAdd) {
+      if (NS_FAILED(target->AddEventListener(eventType, this, false))) {
+        return false;
+      }
+    }
+    else if (NS_FAILED(target->RemoveEventListener(eventType, this, false))) {
+      return false;
+    }
+  }
+
+  if (aUpload) {
+    mUploadEventListenersAttached = aAdd;
+  }
+
+  return true;
+}
+
+NS_IMPL_ISUPPORTS(Proxy, nsIDOMEventListener)
+
+NS_IMETHODIMP
+Proxy::HandleEvent(nsIDOMEvent* aEvent)
+{
+  AssertIsOnMainThread();
+
+  if (!mWorkerPrivate || !mXMLHttpRequestPrivate) {
+    NS_ERROR("Shouldn't get here!");
+    return NS_OK;
+  }
+
+  nsString type;
+  if (NS_FAILED(aEvent->GetType(type))) {
+    NS_WARNING("Failed to get event type!");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMEventTarget> target;
+  if (NS_FAILED(aEvent->GetTarget(getter_AddRefs(target)))) {
+    NS_WARNING("Failed to get target!");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIXMLHttpRequestUpload> uploadTarget = do_QueryInterface(target);
+  ProgressEvent* progressEvent = aEvent->InternalDOMEvent()->AsProgressEvent();
+
+  if (mInOpen && type.EqualsASCII(sEventStrings[STRING_readystatechange])) {
+    uint16_t readyState = 0;
+    if (NS_SUCCEEDED(mXHR->GetReadyState(&readyState)) &&
+        readyState == nsIXMLHttpRequest::OPENED) {
+      mInnerEventStreamId++;
+    }
+  }
+
+  {
+    AutoSafeJSContext cx;
+    JSAutoRequest ar(cx);
+
+    JS::Rooted<JS::Value> value(cx);
+    if (!GetOrCreateDOMReflectorNoWrap(cx, mXHR, &value)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    JS::Rooted<JSObject*> scope(cx, &value.toObject());
+
+    RefPtr<EventRunnable> runnable;
+    if (progressEvent) {
+      runnable = new EventRunnable(this, !!uploadTarget, type,
+                                   progressEvent->LengthComputable(),
+                                   progressEvent->Loaded(),
+                                   progressEvent->Total(),
+                                   scope);
+    }
+    else {
+      runnable = new EventRunnable(this, !!uploadTarget, type, scope);
+    }
+
+    runnable->Dispatch();
+  }
+
+  if (!uploadTarget) {
+    if (type.EqualsASCII(sEventStrings[STRING_loadstart])) {
+      mMainThreadSeenLoadStart = true;
+    }
+    else if (mMainThreadSeenLoadStart &&
+             type.EqualsASCII(sEventStrings[STRING_loadend])) {
+      mMainThreadSeenLoadStart = false;
+
+      RefPtr<LoadStartDetectionRunnable> runnable =
+        new LoadStartDetectionRunnable(this, mXMLHttpRequestPrivate);
+      if (!runnable->RegisterAndDispatch()) {
+        NS_WARNING("Failed to dispatch LoadStartDetectionRunnable!");
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(LoadStartDetectionRunnable, Runnable,
+                                                        nsIDOMEventListener)
+
+NS_IMETHODIMP
+LoadStartDetectionRunnable::Run()
+{
+  AssertIsOnMainThread();
+
+  if (NS_FAILED(mXHR->RemoveEventListener(mEventType, this, false))) {
+    NS_WARNING("Failed to remove event listener!");
+  }
+
+  if (!mReceivedLoadStart) {
+    if (mProxy->mOutstandingSendCount > 1) {
+      mProxy->mOutstandingSendCount--;
+    } else if (mProxy->mOutstandingSendCount == 1) {
+      mProxy->Reset();
+
+      RefPtr<ProxyCompleteRunnable> runnable =
+        new ProxyCompleteRunnable(mWorkerPrivate, mProxy,
+                                  mXMLHttpRequestPrivate, mChannelId);
+      if (runnable->Dispatch()) {
+        mProxy->mWorkerPrivate = nullptr;
+        mProxy->mSyncLoopTarget = nullptr;
+        mProxy->mOutstandingSendCount--;
+      }
+    }
+  }
+
+  mProxy = nullptr;
+  mXHR = nullptr;
+  mXMLHttpRequestPrivate = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+LoadStartDetectionRunnable::HandleEvent(nsIDOMEvent* aEvent)
+{
+  AssertIsOnMainThread();
+
+#ifdef DEBUG
+  {
+    nsString type;
+    if (NS_SUCCEEDED(aEvent->GetType(type))) {
+      MOZ_ASSERT(type == mEventType);
+    }
+    else {
+      NS_WARNING("Failed to get event type!");
+    }
+  }
+#endif
+
+  mReceivedLoadStart = true;
+  return NS_OK;
+}
+
+bool
+EventRunnable::PreDispatch(WorkerPrivate* /* unused */)
+{
+  AssertIsOnMainThread();
+
+  AutoJSAPI jsapi;
+  DebugOnly<bool> ok = jsapi.Init(xpc::NativeGlobal(mScopeObj));
+  MOZ_ASSERT(ok);
+  JSContext* cx = jsapi.cx();
+  // Now keep the mScopeObj alive for the duration
+  JS::Rooted<JSObject*> scopeObj(cx, mScopeObj);
+  // And reset mScopeObj now, before we have a chance to run its destructor on
+  // some background thread.
+  mScopeObj.reset();
+
+  RefPtr<XMLHttpRequestMainThread>& xhr = mProxy->mXHR;
+  MOZ_ASSERT(xhr);
+
+  if (NS_FAILED(xhr->GetResponseType(mResponseType))) {
+    MOZ_ASSERT(false, "This should never fail!");
+  }
+
+  ErrorResult rv;
+  xhr->GetResponseText(mResponseText, rv);
+  mResponseTextResult = rv.StealNSResult();
+
+  if (NS_SUCCEEDED(mResponseTextResult)) {
+    mResponseResult = mResponseTextResult;
+    if (mResponseText.IsVoid()) {
+      mResponse.setNull();
+    }
+  }
+  else {
+    JS::Rooted<JS::Value> response(cx);
+    mResponseResult = xhr->GetResponse(cx, &response);
+    if (NS_SUCCEEDED(mResponseResult)) {
+      if (!response.isGCThing()) {
+        mResponse = response;
+      } else {
+        bool doClone = true;
+        JS::Rooted<JS::Value> transferable(cx);
+        JS::Rooted<JSObject*> obj(cx, response.isObjectOrNull() ?
+                                  response.toObjectOrNull() : nullptr);
+        if (obj && JS_IsArrayBufferObject(obj)) {
+          // Use cached response if the arraybuffer has been transfered.
+          if (mProxy->mArrayBufferResponseWasTransferred) {
+            MOZ_ASSERT(JS_IsDetachedArrayBufferObject(obj));
+            mUseCachedArrayBufferResponse = true;
+            doClone = false;
+          } else {
+            MOZ_ASSERT(!JS_IsDetachedArrayBufferObject(obj));
+            JS::AutoValueArray<1> argv(cx);
+            argv[0].set(response);
+            obj = JS_NewArrayObject(cx, argv);
+            if (obj) {
+              transferable.setObject(*obj);
+              // Only cache the response when the readyState is DONE.
+              if (xhr->ReadyState() == nsIXMLHttpRequest::DONE) {
+                mProxy->mArrayBufferResponseWasTransferred = true;
+              }
+            } else {
+              mResponseResult = NS_ERROR_OUT_OF_MEMORY;
+              doClone = false;
+            }
+          }
+        }
+
+        if (doClone) {
+          Write(cx, response, transferable, JS::CloneDataPolicy(), rv);
+          if (NS_WARN_IF(rv.Failed())) {
+            NS_WARNING("Failed to clone response!");
+            mResponseResult = rv.StealNSResult();
+            mProxy->mArrayBufferResponseWasTransferred = false;
+          }
+        }
+      }
+    }
+  }
+
+  mStatusResult = xhr->GetStatus(&mStatus);
+
+  xhr->GetStatusText(mStatusText, rv);
+  MOZ_ASSERT(!rv.Failed());
+
+  mReadyState = xhr->ReadyState();
+
+  xhr->GetResponseURL(mResponseURL);
+
+  return true;
+}
+
+bool
+EventRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
+{
+  if (mEventStreamId != mProxy->mOuterEventStreamId) {
+    // Threads raced, this event is now obsolete.
+    return true;
+  }
+
+  if (!mProxy->mXMLHttpRequestPrivate) {
+    // Object was finalized, bail.
+    return true;
+  }
+
+  if (mType.EqualsASCII(sEventStrings[STRING_loadstart])) {
+    if (mUploadEvent) {
+      mProxy->mSeenUploadLoadStart = true;
+    }
+    else {
+      mProxy->mSeenLoadStart = true;
+    }
+  }
+  else if (mType.EqualsASCII(sEventStrings[STRING_loadend])) {
+    if (mUploadEvent) {
+      mProxy->mSeenUploadLoadStart = false;
+    }
+    else {
+      if (!mProxy->mSeenLoadStart) {
+        // We've already dispatched premature abort events.
+        return true;
+      }
+      mProxy->mSeenLoadStart = false;
+    }
+  }
+  else if (mType.EqualsASCII(sEventStrings[STRING_abort])) {
+    if ((mUploadEvent && !mProxy->mSeenUploadLoadStart) ||
+        (!mUploadEvent && !mProxy->mSeenLoadStart)) {
+      // We've already dispatched premature abort events.
+      return true;
+    }
+  }
+
+  if (mProgressEvent) {
+    // Cache these for premature abort events.
+    if (mUploadEvent) {
+      mProxy->mLastUploadLengthComputable = mLengthComputable;
+      mProxy->mLastUploadLoaded = mLoaded;
+      mProxy->mLastUploadTotal = mTotal;
+    }
+    else {
+      mProxy->mLastLengthComputable = mLengthComputable;
+      mProxy->mLastLoaded = mLoaded;
+      mProxy->mLastTotal = mTotal;
+    }
+  }
+
+  JS::Rooted<UniquePtr<XMLHttpRequestWorker::StateData>> state(aCx, new XMLHttpRequestWorker::StateData());
+
+  state->mResponseTextResult = mResponseTextResult;
+
+  state->mResponseText = mResponseText;
+
+  if (NS_SUCCEEDED(mResponseTextResult)) {
+    MOZ_ASSERT(mResponse.isUndefined() || mResponse.isNull());
+    state->mResponseResult = mResponseTextResult;
+    state->mResponse = mResponse;
+  }
+  else {
+    state->mResponseResult = mResponseResult;
+
+    if (NS_SUCCEEDED(mResponseResult)) {
+      if (HasData()) {
+        MOZ_ASSERT(mResponse.isUndefined());
+
+        ErrorResult rv;
+        JS::Rooted<JS::Value> response(aCx);
+
+        GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper());
+        nsCOMPtr<nsIGlobalObject> global =
+          do_QueryInterface(globalObj.GetAsSupports());
+
+        Read(global, aCx, &response, rv);
+        if (NS_WARN_IF(rv.Failed())) {
+          rv.SuppressException();
+          return false;
+        }
+
+        state->mResponse = response;
+      }
+      else {
+        state->mResponse = mResponse;
+      }
+    }
+  }
+
+  state->mStatusResult = mStatusResult;
+  state->mStatus = mStatus;
+
+  state->mStatusText = mStatusText;
+
+  state->mReadyState = mReadyState;
+
+  state->mResponseURL = mResponseURL;
+
+  XMLHttpRequestWorker* xhr = mProxy->mXMLHttpRequestPrivate;
+  xhr->UpdateState(*state.get(), mUseCachedArrayBufferResponse);
+
+  if (mType.EqualsASCII(sEventStrings[STRING_readystatechange])) {
+    if (mReadyState == 4 && !mUploadEvent && !mProxy->mSeenLoadStart) {
+      // We've already dispatched premature abort events.
+      return true;
+    }
+  }
+
+  if (mUploadEvent && !xhr->GetUploadObjectNoCreate()) {
+    return true;
+  }
+
+  JS::Rooted<JSString*> type(aCx,
+    JS_NewUCStringCopyN(aCx, mType.get(), mType.Length()));
+  if (!type) {
+    return false;
+  }
+
+  XMLHttpRequestEventTarget* target;
+  if (mUploadEvent) {
+    target = xhr->GetUploadObjectNoCreate();
+  }
+  else {
+    target = xhr;
+  }
+
+  MOZ_ASSERT(target);
+
+  RefPtr<Event> event;
+  if (mProgressEvent) {
+    ProgressEventInit init;
+    init.mBubbles = false;
+    init.mCancelable = false;
+    init.mLengthComputable = mLengthComputable;
+    init.mLoaded = mLoaded;
+    init.mTotal = mTotal;
+
+    event = ProgressEvent::Constructor(target, mType, init);
+  }
+  else {
+    event = NS_NewDOMEvent(target, nullptr, nullptr);
+
+    if (event) {
+      event->InitEvent(mType, false, false);
+    }
+  }
+
+  if (!event) {
+    return false;
+  }
+
+  event->SetTrusted(true);
+
+  target->DispatchDOMEvent(nullptr, event, nullptr, nullptr);
+
+  // After firing the event set mResponse to JSVAL_NULL for chunked response
+  // types.
+  if (StringBeginsWith(mResponseType, NS_LITERAL_STRING("moz-chunked-"))) {
+    xhr->NullResponseText();
+  }
+
+  return true;
+}
+
+bool
+WorkerThreadProxySyncRunnable::MainThreadRun()
+{
+  AssertIsOnMainThread();
+
+  nsCOMPtr<nsIEventTarget> tempTarget = mSyncLoopTarget;
+
+  mProxy->mSyncEventResponseTarget.swap(tempTarget);
+
+  ErrorResult rv;
+  RunOnMainThread(rv);
+  mErrorCode = rv.StealNSResult();
+
+  mProxy->mSyncEventResponseTarget.swap(tempTarget);
+
+  return true;
+}
+
+void
+AbortRunnable::RunOnMainThread(ErrorResult& aRv)
+{
+  mProxy->mInnerEventStreamId++;
+
+  WorkerPrivate* oldWorker = mProxy->mWorkerPrivate;
+  mProxy->mWorkerPrivate = mWorkerPrivate;
+
+  mProxy->mXHR->Abort(aRv);
+
+  mProxy->mWorkerPrivate = oldWorker;
+
+  mProxy->Reset();
+}
+
+nsresult
+OpenRunnable::MainThreadRunInternal()
+{
+  if (!mProxy->Init()) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  nsresult rv;
+
+  if (mBackgroundRequest) {
+    rv = mProxy->mXHR->SetMozBackgroundRequest(mBackgroundRequest);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (mWithCredentials) {
+    rv = mProxy->mXHR->SetWithCredentials(mWithCredentials);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (mTimeout) {
+    rv = mProxy->mXHR->SetTimeout(mTimeout);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  MOZ_ASSERT(!mProxy->mInOpen);
+  mProxy->mInOpen = true;
+
+  ErrorResult rv2;
+  mProxy->mXHR->Open(mMethod, mURL, true,
+                     mUser.WasPassed() ? mUser.Value() : NullString(),
+                     mPassword.WasPassed() ? mPassword.Value() : NullString(),
+                     rv2);
+
+  MOZ_ASSERT(mProxy->mInOpen);
+  mProxy->mInOpen = false;
+
+  if (rv2.Failed()) {
+    return rv2.StealNSResult();
+  }
+
+  mProxy->mXHR->SetResponseType(mResponseType, rv2);
+  if (rv2.Failed()) {
+    return rv2.StealNSResult();
+  }
+
+  return NS_OK;
+}
+
+void
+SendRunnable::RunOnMainThread(ErrorResult& aRv)
+{
+  nsCOMPtr<nsIVariant> variant;
+
+  if (HasData()) {
+    AutoSafeJSContext cx;
+    JSAutoRequest ar(cx);
+
+    nsIXPConnect* xpc = nsContentUtils::XPConnect();
+    MOZ_ASSERT(xpc);
+
+    JS::Rooted<JSObject*> globalObject(cx, JS::CurrentGlobalOrNull(cx));
+    if (NS_WARN_IF(!globalObject)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+
+    nsCOMPtr<nsIGlobalObject> parent = xpc::NativeGlobal(globalObject);
+    if (NS_WARN_IF(!parent)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+
+    JS::Rooted<JS::Value> body(cx);
+    Read(parent, cx, &body, aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return;
+    }
+
+    aRv = xpc->JSValToVariant(cx, body, getter_AddRefs(variant));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return;
+    }
+  }
+  else {
+    RefPtr<nsVariant> wvariant = new nsVariant();
+
+    if (NS_FAILED(wvariant->SetAsAString(mStringBody))) {
+      MOZ_ASSERT(false, "This should never fail!");
+    }
+
+    variant = wvariant;
+  }
+
+  // Send() has been already called, reset the proxy.
+  if (mProxy->mWorkerPrivate) {
+    mProxy->Reset();
+  }
+
+  mProxy->mWorkerPrivate = mWorkerPrivate;
+
+  MOZ_ASSERT(!mProxy->mSyncLoopTarget);
+  mProxy->mSyncLoopTarget.swap(mSyncLoopTarget);
+
+  if (mHasUploadListeners) {
+    // Send() can be called more than once before failure,
+    // so don't attach the upload listeners more than once.
+    if (!mProxy->mUploadEventListenersAttached &&
+        !mProxy->AddRemoveEventListeners(true, true)) {
+      MOZ_ASSERT(false, "This should never fail!");
+    }
+  }
+
+  mProxy->mArrayBufferResponseWasTransferred = false;
+
+  mProxy->mInnerChannelId++;
+
+  aRv = mProxy->mXHR->Send(variant);
+
+  if (!aRv.Failed()) {
+    mProxy->mOutstandingSendCount++;
+
+    if (!mHasUploadListeners) {
+      // Send() can be called more than once before failure,
+      // so don't attach the upload listeners more than once.
+      if (!mProxy->mUploadEventListenersAttached &&
+          !mProxy->AddRemoveEventListeners(true, true)) {
+        MOZ_ASSERT(false, "This should never fail!");
+      }
+    }
+  }
+}
+
+XMLHttpRequestWorker::XMLHttpRequestWorker(WorkerPrivate* aWorkerPrivate)
+: mWorkerPrivate(aWorkerPrivate),
+  mResponseType(XMLHttpRequestResponseType::Text), mTimeout(0),
+  mRooted(false), mBackgroundRequest(false), mWithCredentials(false),
+  mCanceled(false), mMozAnon(false), mMozSystem(false)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  mozilla::HoldJSObjects(this);
+}
+
+XMLHttpRequestWorker::~XMLHttpRequestWorker()
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  ReleaseProxy(XHRIsGoingAway);
+
+  MOZ_ASSERT(!mRooted);
+
+  mozilla::DropJSObjects(this);
+}
+
+NS_IMPL_ADDREF_INHERITED(XMLHttpRequestWorker, XMLHttpRequestEventTarget)
+NS_IMPL_RELEASE_INHERITED(XMLHttpRequestWorker, XMLHttpRequestEventTarget)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(XMLHttpRequestWorker)
+NS_INTERFACE_MAP_END_INHERITING(XMLHttpRequestEventTarget)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(XMLHttpRequestWorker)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(XMLHttpRequestWorker,
+                                                  XMLHttpRequestEventTarget)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUpload)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(XMLHttpRequestWorker,
+                                                XMLHttpRequestEventTarget)
+  tmp->ReleaseProxy(XHRIsGoingAway);
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mUpload)
+  tmp->mStateData.mResponse.setUndefined();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(XMLHttpRequestWorker,
+                                               XMLHttpRequestEventTarget)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mStateData.mResponse)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+/* static */ already_AddRefed<XMLHttpRequest>
+XMLHttpRequestWorker::Construct(const GlobalObject& aGlobal,
+                                const MozXMLHttpRequestParameters& aParams,
+                                ErrorResult& aRv)
+{
+  JSContext* cx = aGlobal.Context();
+  WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+  MOZ_ASSERT(workerPrivate);
+
+  Telemetry::Accumulate(Telemetry::XHR_IN_WORKER, 1);
+
+  RefPtr<XMLHttpRequestWorker> xhr = new XMLHttpRequestWorker(workerPrivate);
+
+  if (workerPrivate->XHRParamsAllowed()) {
+    if (aParams.mMozSystem)
+      xhr->mMozAnon = true;
+    else
+      xhr->mMozAnon = aParams.mMozAnon;
+    xhr->mMozSystem = aParams.mMozSystem;
+  }
+
+  return xhr.forget();
+}
+
+void
+XMLHttpRequestWorker::ReleaseProxy(ReleaseType aType)
+{
+  // Can't assert that we're on the worker thread here because mWorkerPrivate
+  // may be gone.
+
+  if (mProxy) {
+    if (aType == XHRIsGoingAway) {
+      // We're in a GC finalizer, so we can't do a sync call here (and we don't
+      // need to).
+      RefPtr<AsyncTeardownRunnable> runnable =
+        new AsyncTeardownRunnable(mProxy);
+      mProxy = nullptr;
+
+      if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable.forget()))) {
+        NS_ERROR("Failed to dispatch teardown runnable!");
+      }
+    } else {
+      // This isn't necessary if the worker is going away or the XHR is going
+      // away.
+      if (aType == Default) {
+        // Don't let any more events run.
+        mProxy->mOuterEventStreamId++;
+      }
+
+      // We need to make a sync call here.
+      RefPtr<SyncTeardownRunnable> runnable =
+        new SyncTeardownRunnable(mWorkerPrivate, mProxy);
+      mProxy = nullptr;
+
+      ErrorResult forAssertionsOnly;
+      runnable->Dispatch(forAssertionsOnly);
+      if (forAssertionsOnly.Failed()) {
+        NS_ERROR("Failed to dispatch teardown runnable!");
+      }
+    }
+  }
+}
+
+void
+XMLHttpRequestWorker::MaybePin(ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mRooted) {
+    return;
+  }
+
+  if (!HoldWorker(mWorkerPrivate, Canceling)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  NS_ADDREF_THIS();
+
+  mRooted = true;
+}
+
+void
+XMLHttpRequestWorker::MaybeDispatchPrematureAbortEvents(ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+  MOZ_ASSERT(mProxy);
+
+  // Only send readystatechange event when state changed.
+  bool isStateChanged = false;
+  if (mStateData.mReadyState != 4) {
+    isStateChanged = true;
+    mStateData.mReadyState = 4;
+  }
+
+  if (mProxy->mSeenUploadLoadStart) {
+    MOZ_ASSERT(mUpload);
+
+    DispatchPrematureAbortEvent(mUpload, NS_LITERAL_STRING("abort"), true,
+                                aRv);
+    if (aRv.Failed()) {
+      return;
+    }
+
+    DispatchPrematureAbortEvent(mUpload, NS_LITERAL_STRING("loadend"), true,
+                                aRv);
+    if (aRv.Failed()) {
+      return;
+    }
+
+    mProxy->mSeenUploadLoadStart = false;
+  }
+
+  if (mProxy->mSeenLoadStart) {
+    if (isStateChanged) {
+      DispatchPrematureAbortEvent(this, NS_LITERAL_STRING("readystatechange"),
+                                  false, aRv);
+      if (aRv.Failed()) {
+        return;
+      }
+    }
+
+    DispatchPrematureAbortEvent(this, NS_LITERAL_STRING("abort"), false, aRv);
+    if (aRv.Failed()) {
+      return;
+    }
+
+    DispatchPrematureAbortEvent(this, NS_LITERAL_STRING("loadend"), false,
+                                aRv);
+    if (aRv.Failed()) {
+      return;
+    }
+
+    mProxy->mSeenLoadStart = false;
+  }
+}
+
+void
+XMLHttpRequestWorker::DispatchPrematureAbortEvent(EventTarget* aTarget,
+                                                  const nsAString& aEventType,
+                                                  bool aUploadTarget,
+                                                  ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+  MOZ_ASSERT(aTarget);
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  RefPtr<Event> event;
+  if (aEventType.EqualsLiteral("readystatechange")) {
+    event = NS_NewDOMEvent(aTarget, nullptr, nullptr);
+    event->InitEvent(aEventType, false, false);
+  }
+  else {
+    ProgressEventInit init;
+    init.mBubbles = false;
+    init.mCancelable = false;
+    if (aUploadTarget) {
+      init.mLengthComputable = mProxy->mLastUploadLengthComputable;
+      init.mLoaded = mProxy->mLastUploadLoaded;
+      init.mTotal = mProxy->mLastUploadTotal;
+    }
+    else {
+      init.mLengthComputable = mProxy->mLastLengthComputable;
+      init.mLoaded = mProxy->mLastLoaded;
+      init.mTotal = mProxy->mLastTotal;
+    }
+    event = ProgressEvent::Constructor(aTarget, aEventType, init);
+  }
+
+  if (!event) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  event->SetTrusted(true);
+
+  aTarget->DispatchDOMEvent(nullptr, event, nullptr, nullptr);
+}
+
+void
+XMLHttpRequestWorker::Unpin()
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  MOZ_ASSERT(mRooted, "Mismatched calls to Unpin!");
+
+  ReleaseWorker();
+
+  mRooted = false;
+
+  NS_RELEASE_THIS();
+}
+
+void
+XMLHttpRequestWorker::SendInternal(SendRunnable* aRunnable,
+                                   ErrorResult& aRv)
+{
+  MOZ_ASSERT(aRunnable);
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  // No send() calls when open is running.
+  if (mProxy->mOpenCount) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  bool hasUploadListeners = mUpload ? mUpload->HasListeners() : false;
+
+  MaybePin(aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  AutoUnpinXHR autoUnpin(this);
+  Maybe<AutoSyncLoopHolder> autoSyncLoop;
+
+  nsCOMPtr<nsIEventTarget> syncLoopTarget;
+  bool isSyncXHR = mProxy->mIsSyncXHR;
+  if (isSyncXHR) {
+    autoSyncLoop.emplace(mWorkerPrivate);
+    syncLoopTarget = autoSyncLoop->EventTarget();
+  }
+
+  mProxy->mOuterChannelId++;
+
+  aRunnable->SetSyncLoopTarget(syncLoopTarget);
+  aRunnable->SetHaveUploadListeners(hasUploadListeners);
+
+  aRunnable->Dispatch(aRv);
+  if (aRv.Failed()) {
+    // Dispatch() may have spun the event loop and we may have already unrooted.
+    // If so we don't want autoUnpin to try again.
+    if (!mRooted) {
+      autoUnpin.Clear();
+    }
+    return;
+  }
+
+  if (!isSyncXHR)  {
+    autoUnpin.Clear();
+    MOZ_ASSERT(!autoSyncLoop);
+    return;
+  }
+
+  autoUnpin.Clear();
+
+  // Don't clobber an existing exception that we may have thrown on aRv
+  // already... though can there really be one?  In any case, it seems to me
+  // that this autoSyncLoop->Run() can never fail, since the StopSyncLoop call
+  // for it will come from ProxyCompleteRunnable and that always passes true for
+  // the second arg.
+  if (!autoSyncLoop->Run() && !aRv.Failed()) {
+    aRv.Throw(NS_ERROR_FAILURE);
+  }
+}
+
+bool
+XMLHttpRequestWorker::Notify(Status aStatus)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (aStatus >= Canceling && !mCanceled) {
+    mCanceled = true;
+    ReleaseProxy(WorkerIsGoingAway);
+  }
+
+  return true;
+}
+
+void
+XMLHttpRequestWorker::Open(const nsACString& aMethod,
+                           const nsAString& aUrl, bool aAsync,
+                           const Optional<nsAString>& aUser,
+                           const Optional<nsAString>& aPassword,
+                           ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (mProxy) {
+    MaybeDispatchPrematureAbortEvents(aRv);
+    if (aRv.Failed()) {
+      return;
+    }
+  }
+  else {
+    mProxy = new Proxy(this, mMozAnon, mMozSystem);
+  }
+
+  mProxy->mOuterEventStreamId++;
+
+  RefPtr<OpenRunnable> runnable =
+    new OpenRunnable(mWorkerPrivate, mProxy, aMethod, aUrl, aUser, aPassword,
+                     mBackgroundRequest, mWithCredentials,
+                     mTimeout, mResponseType);
+
+  ++mProxy->mOpenCount;
+  runnable->Dispatch(aRv);
+  if (aRv.Failed()) {
+    if (mProxy && !--mProxy->mOpenCount) {
+      ReleaseProxy();
+    }
+
+    return;
+  }
+
+  // We have been released in one of the nested Open() calls.
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  --mProxy->mOpenCount;
+  mProxy->mIsSyncXHR = !aAsync;
+}
+
+void
+XMLHttpRequestWorker::SetRequestHeader(const nsACString& aHeader,
+                                       const nsACString& aValue, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  RefPtr<SetRequestHeaderRunnable> runnable =
+    new SetRequestHeaderRunnable(mWorkerPrivate, mProxy, aHeader, aValue);
+  runnable->Dispatch(aRv);
+}
+
+void
+XMLHttpRequestWorker::SetTimeout(uint32_t aTimeout, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  mTimeout = aTimeout;
+
+  if (!mProxy) {
+    // Open may not have been called yet, in which case we'll handle the
+    // timeout in OpenRunnable.
+    return;
+  }
+
+  RefPtr<SetTimeoutRunnable> runnable =
+    new SetTimeoutRunnable(mWorkerPrivate, mProxy, aTimeout);
+  runnable->Dispatch(aRv);
+}
+
+void
+XMLHttpRequestWorker::SetWithCredentials(bool aWithCredentials, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  mWithCredentials = aWithCredentials;
+
+  if (!mProxy) {
+    // Open may not have been called yet, in which case we'll handle the
+    // credentials in OpenRunnable.
+    return;
+  }
+
+  RefPtr<SetWithCredentialsRunnable> runnable =
+    new SetWithCredentialsRunnable(mWorkerPrivate, mProxy, aWithCredentials);
+  runnable->Dispatch(aRv);
+}
+
+void
+XMLHttpRequestWorker::SetMozBackgroundRequest(bool aBackgroundRequest,
+                                              ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  mBackgroundRequest = aBackgroundRequest;
+
+  if (!mProxy) {
+    // Open may not have been called yet, in which case we'll handle the
+    // background request in OpenRunnable.
+    return;
+  }
+
+  RefPtr<SetBackgroundRequestRunnable> runnable =
+    new SetBackgroundRequestRunnable(mWorkerPrivate, mProxy,
+                                     aBackgroundRequest);
+  runnable->Dispatch(aRv);
+}
+
+XMLHttpRequestUpload*
+XMLHttpRequestWorker::GetUpload(ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return nullptr;
+  }
+
+  if (!mUpload) {
+    mUpload = new XMLHttpRequestUpload();
+
+    if (!mUpload) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
+    }
+  }
+
+  return mUpload;
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, NullString());
+
+  // Nothing to clone.
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, const nsAString& aBody,
+                           ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, aBody);
+
+  // Nothing to clone.
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, JS::Handle<JSObject*> aBody,
+                           ErrorResult& aRv)
+{
+  MOZ_ASSERT(aBody);
+
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  JS::Rooted<JS::Value> valToClone(aCx);
+  if (JS_IsArrayBufferObject(aBody) || JS_IsArrayBufferViewObject(aBody)) {
+    valToClone.setObject(*aBody);
+  }
+  else {
+    JS::Rooted<JS::Value> obj(aCx, JS::ObjectValue(*aBody));
+    JSString* bodyStr = JS::ToString(aCx, obj);
+    if (!bodyStr) {
+      aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+      return;
+    }
+    valToClone.setString(bodyStr);
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, EmptyString());
+
+  sendRunnable->Write(aCx, valToClone, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, Blob& aBody, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  JS::Rooted<JS::Value> value(aCx);
+  if (!GetOrCreateDOMReflector(aCx, &aBody, &value)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  RefPtr<BlobImpl> blobImpl = aBody.Impl();
+  MOZ_ASSERT(blobImpl);
+
+  aRv = blobImpl->SetMutable(false);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, EmptyString());
+
+  sendRunnable->Write(aCx, value, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, FormData& aBody, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  JS::Rooted<JS::Value> value(aCx);
+  if (!GetOrCreateDOMReflector(aCx, &aBody, &value)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, EmptyString());
+
+  sendRunnable->Write(aCx, value, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, URLSearchParams& aBody,
+                           ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  JS::Rooted<JS::Value> value(aCx);
+  if (!GetOrCreateDOMReflector(aCx, &aBody, &value)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return;
+  }
+
+  RefPtr<SendRunnable> sendRunnable =
+    new SendRunnable(mWorkerPrivate, mProxy, EmptyString());
+
+  sendRunnable->Write(aCx, value, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  SendInternal(sendRunnable, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, const ArrayBuffer& aBody,
+                           ErrorResult& aRv)
+{
+  JS::Rooted<JSObject*> obj(mWorkerPrivate->GetJSContext(), aBody.Obj());
+  return Send(aCx, obj, aRv);
+}
+
+void
+XMLHttpRequestWorker::Send(JSContext* aCx, const ArrayBufferView& aBody,
+                           ErrorResult& aRv)
+{
+  if (JS_IsTypedArrayObject(aBody.Obj()) &&
+      JS_GetTypedArraySharedness(aBody.Obj())) {
+    // Throw if the object is mapping shared memory (must opt in).
+    aRv.ThrowTypeError<MSG_TYPEDARRAY_IS_SHARED>(NS_LITERAL_STRING("Argument of XMLHttpRequest.send"));
+    return;
+  }
+  JS::Rooted<JSObject*> obj(aCx, aBody.Obj());
+  return Send(aCx, obj, aRv);
+}
+
+void
+XMLHttpRequestWorker::Abort(ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    return;
+  }
+
+  MaybeDispatchPrematureAbortEvents(aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  if (mStateData.mReadyState == 4) {
+    // No one did anything to us while we fired abort events, so reset our state
+    // to "unsent"
+    mStateData.mReadyState = 0;
+  }
+
+  mProxy->mOuterEventStreamId++;
+
+  RefPtr<AbortRunnable> runnable = new AbortRunnable(mWorkerPrivate, mProxy);
+  runnable->Dispatch(aRv);
+}
+
+void
+XMLHttpRequestWorker::GetResponseHeader(const nsACString& aHeader,
+                                        nsACString& aResponseHeader, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCString responseHeader;
+  RefPtr<GetResponseHeaderRunnable> runnable =
+    new GetResponseHeaderRunnable(mWorkerPrivate, mProxy, aHeader,
+                                  responseHeader);
+  runnable->Dispatch(aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+  aResponseHeader = responseHeader;
+}
+
+void
+XMLHttpRequestWorker::GetAllResponseHeaders(nsACString& aResponseHeaders,
+                                            ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  if (!mProxy) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCString responseHeaders;
+  RefPtr<GetAllResponseHeadersRunnable> runnable =
+    new GetAllResponseHeadersRunnable(mWorkerPrivate, mProxy, responseHeaders);
+  runnable->Dispatch(aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  aResponseHeaders = responseHeaders;
+}
+
+void
+XMLHttpRequestWorker::OverrideMimeType(const nsAString& aMimeType, ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  // We're supposed to throw if the state is not OPENED or HEADERS_RECEIVED. We
+  // can detect OPENED really easily but we can't detect HEADERS_RECEIVED in a
+  // non-racy way until the XHR state machine actually runs on this thread
+  // (bug 671047). For now we're going to let this work only if the Send()
+  // method has not been called, unless the send has been aborted.
+  if (!mProxy || (SendInProgress() &&
+                  (mProxy->mSeenLoadStart ||
+                   mStateData.mReadyState > nsIXMLHttpRequest::OPENED))) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  RefPtr<OverrideMimeTypeRunnable> runnable =
+    new OverrideMimeTypeRunnable(mWorkerPrivate, mProxy, aMimeType);
+  runnable->Dispatch(aRv);
+}
+
+void
+XMLHttpRequestWorker::SetResponseType(XMLHttpRequestResponseType aResponseType,
+                                      ErrorResult& aRv)
+{
+  mWorkerPrivate->AssertIsOnWorkerThread();
+
+  if (mCanceled) {
+    aRv.ThrowUncatchableException();
+    return;
+  }
+
+  // "document" is fine for the main thread but not for a worker. Short-circuit
+  // that here.
+  if (aResponseType == XMLHttpRequestResponseType::Document) {
+    return;
+  }
+
+  if (!mProxy) {
+    // Open() has not been called yet. We store the responseType and we will use
+    // it later in Open().
+    mResponseType = aResponseType;
+    return;
+  }
+
+  if (SendInProgress() &&
+      (mProxy->mSeenLoadStart ||
+       mStateData.mReadyState > nsIXMLHttpRequest::OPENED)) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  RefPtr<SetResponseTypeRunnable> runnable =
+    new SetResponseTypeRunnable(mWorkerPrivate, mProxy, aResponseType);
+  runnable->Dispatch(aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  mResponseType = runnable->ResponseType();
+}
+
+void
+XMLHttpRequestWorker::GetResponse(JSContext* /* unused */,
+                                  JS::MutableHandle<JS::Value> aResponse,
+                                  ErrorResult& aRv)
+{
+  if (NS_SUCCEEDED(mStateData.mResponseTextResult) &&
+      mStateData.mResponse.isUndefined()) {
+    MOZ_ASSERT(NS_SUCCEEDED(mStateData.mResponseResult));
+
+    if (mStateData.mResponseText.IsEmpty()) {
+      mStateData.mResponse =
+        JS_GetEmptyStringValue(mWorkerPrivate->GetJSContext());
+    } else {
+      XMLHttpRequestStringSnapshotReaderHelper helper(mStateData.mResponseText);
+
+      JSString* str =
+        JS_NewUCStringCopyN(mWorkerPrivate->GetJSContext(),
+                            helper.Buffer(), helper.Length());
+
+      if (!str) {
+        aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+        return;
+      }
+
+      mStateData.mResponse.setString(str);
+    }
+  }
+
+  aRv = mStateData.mResponseResult;
+  aResponse.set(mStateData.mResponse);
+}
+
+void
+XMLHttpRequestWorker::GetResponseText(DOMString& aResponseText, ErrorResult& aRv)
+{
+  aRv = mStateData.mResponseTextResult;
+  if (aRv.Failed()) {
+    return;
+  }
+
+  if (!mStateData.mResponseText.GetAsString(aResponseText)) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+}
+
+void
+XMLHttpRequestWorker::UpdateState(const StateData& aStateData,
+                                  bool aUseCachedArrayBufferResponse)
+{
+  if (aUseCachedArrayBufferResponse) {
+    MOZ_ASSERT(mStateData.mResponse.isObject() &&
+               JS_IsArrayBufferObject(&mStateData.mResponse.toObject()));
+
+    JS::Rooted<JS::Value> response(mWorkerPrivate->GetJSContext(),
+                                   mStateData.mResponse);
+    mStateData = aStateData;
+    mStateData.mResponse = response;
+  }
+  else {
+    mStateData = aStateData;
+  }
+
+  XMLHttpRequestBinding::ClearCachedResponseTextValue(this);
+}
+
+} // dom namespace
+} // mozilla namespace