Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

67 files changed, 7823 insertions, 0 deletions

diff --git a/dom/websocket/WebSocket.cpp b/dom/websocket/WebSocket.cpp
new file mode 100644
index 0000000000..39b3501ea2
--- /dev/null
+++ b/dom/websocket/WebSocket.cpp
@@ -0,0 +1,2891 @@
+/* -*- 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 "WebSocket.h"
+#include "mozilla/dom/WebSocketBinding.h"
+#include "mozilla/net/WebSocketChannel.h"
+
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MessageEvent.h"
+#include "mozilla/dom/MessageEventBinding.h"
+#include "mozilla/dom/nsCSPContext.h"
+#include "mozilla/dom/nsCSPUtils.h"
+#include "mozilla/dom/nsHTTPSOnlyUtils.h"
+#include "mozilla/dom/nsMixedContentBlocker.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/SerializedStackHolder.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/dom/WorkerRunnable.h"
+#include "mozilla/dom/WorkerScope.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/LoadInfo.h"
+#include "nsGlobalWindow.h"
+#include "nsIScriptGlobalObject.h"
+#include "mozilla/dom/Document.h"
+#include "nsXPCOM.h"
+#include "nsContentUtils.h"
+#include "nsError.h"
+#include "nsICookieJarSettings.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIURL.h"
+#include "nsThreadUtils.h"
+#include "nsIPromptFactory.h"
+#include "nsIWindowWatcher.h"
+#include "nsIPrompt.h"
+#include "nsIStringBundle.h"
+#include "nsIConsoleService.h"
+#include "mozilla/dom/CloseEvent.h"
+#include "mozilla/net/WebSocketEventService.h"
+#include "nsJSUtils.h"
+#include "nsIScriptError.h"
+#include "nsNetUtil.h"
+#include "nsIAuthPrompt.h"
+#include "nsIAuthPrompt2.h"
+#include "nsILoadGroup.h"
+#include "mozilla/Preferences.h"
+#include "xpcpublic.h"
+#include "nsContentPolicyUtils.h"
+#include "nsWrapperCacheInlines.h"
+#include "nsIObserverService.h"
+#include "nsIEventTarget.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIObserver.h"
+#include "nsIRequest.h"
+#include "nsIThreadRetargetableRequest.h"
+#include "nsIWebSocketChannel.h"
+#include "nsIWebSocketListener.h"
+#include "nsProxyRelease.h"
+#include "nsWeakReference.h"
+#include "nsIWebSocketImpl.h"
+
+#define OPEN_EVENT_STRING u"open"_ns
+#define MESSAGE_EVENT_STRING u"message"_ns
+#define ERROR_EVENT_STRING u"error"_ns
+#define CLOSE_EVENT_STRING u"close"_ns
+
+using namespace mozilla::net;
+
+namespace mozilla::dom {
+
+class WebSocketImpl;
+
+// This class is responsible for proxying nsIObserver and nsIWebSocketImpl
+// interfaces to WebSocketImpl. WebSocketImplProxy should be only accessed on
+// main thread, so we can let it support weak reference.
+class WebSocketImplProxy final : public nsIObserver,
+                                 public nsSupportsWeakReference,
+                                 public nsIWebSocketImpl {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIWEBSOCKETIMPL
+
+  explicit WebSocketImplProxy(WebSocketImpl* aOwner) : mOwner(aOwner) {
+    MOZ_ASSERT(NS_IsMainThread());
+  }
+
+  void Disconnect() {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    mOwner = nullptr;
+  }
+
+ private:
+  ~WebSocketImplProxy() = default;
+
+  RefPtr<WebSocketImpl> mOwner;
+};
+
+class WebSocketImpl final : public nsIInterfaceRequestor,
+                            public nsIWebSocketListener,
+                            public nsIObserver,
+                            public nsIRequest,
+                            public nsISerialEventTarget,
+                            public nsIWebSocketImpl {
+ public:
+  NS_DECL_NSIINTERFACEREQUESTOR
+  NS_DECL_NSIWEBSOCKETLISTENER
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIREQUEST
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIEVENTTARGET_FULL
+  NS_DECL_NSIWEBSOCKETIMPL
+
+  explicit WebSocketImpl(WebSocket* aWebSocket)
+      : mWebSocket(aWebSocket),
+        mIsServerSide(false),
+        mSecure(false),
+        mOnCloseScheduled(false),
+        mFailed(false),
+        mDisconnectingOrDisconnected(false),
+        mCloseEventWasClean(false),
+        mCloseEventCode(nsIWebSocketChannel::CLOSE_ABNORMAL),
+        mPort(0),
+        mScriptLine(0),
+        mScriptColumn(0),
+        mInnerWindowID(0),
+        mPrivateBrowsing(false),
+        mIsChromeContext(false),
+        mIsMainThread(true),
+        mMutex("WebSocketImpl::mMutex"),
+        mWorkerShuttingDown(false) {
+    if (!NS_IsMainThread()) {
+      mIsMainThread = false;
+    }
+  }
+
+  void AssertIsOnTargetThread() const { MOZ_ASSERT(IsTargetThread()); }
+
+  bool IsTargetThread() const;
+
+  nsresult Init(JSContext* aCx, bool aIsSecure, nsIPrincipal* aPrincipal,
+                const Maybe<ClientInfo>& aClientInfo,
+                nsICSPEventListener* aCSPEventListener, bool aIsServerSide,
+                const nsAString& aURL, nsTArray<nsString>& aProtocolArray,
+                const nsACString& aScriptFile, uint32_t aScriptLine,
+                uint32_t aScriptColumn);
+
+  nsresult AsyncOpen(nsIPrincipal* aPrincipal, uint64_t aInnerWindowID,
+                     nsITransportProvider* aTransportProvider,
+                     const nsACString& aNegotiatedExtensions,
+                     UniquePtr<SerializedStackHolder> aOriginStack);
+
+  nsresult ParseURL(const nsAString& aURL);
+  nsresult InitializeConnection(nsIPrincipal* aPrincipal,
+                                nsICookieJarSettings* aCookieJarSettings);
+
+  // These methods when called can release the WebSocket object
+  void FailConnection(uint16_t reasonCode,
+                      const nsACString& aReasonString = ""_ns);
+  nsresult CloseConnection(uint16_t reasonCode,
+                           const nsACString& aReasonString = ""_ns);
+  void Disconnect();
+  void DisconnectInternal();
+
+  nsresult ConsoleError();
+  void PrintErrorOnConsole(const char* aBundleURI, const char* aError,
+                           nsTArray<nsString>&& aFormatStrings);
+
+  nsresult DoOnMessageAvailable(const nsACString& aMsg, bool isBinary) const;
+
+  // ConnectionCloseEvents: 'error' event if needed, then 'close' event.
+  nsresult ScheduleConnectionCloseEvents(nsISupports* aContext,
+                                         nsresult aStatusCode);
+  // 2nd half of ScheduleConnectionCloseEvents, run in its own event.
+  void DispatchConnectionCloseEvents();
+
+  nsresult UpdateURI();
+
+  void AddRefObject();
+  void ReleaseObject();
+
+  bool RegisterWorkerRef(WorkerPrivate* aWorkerPrivate);
+  void UnregisterWorkerRef();
+
+  nsresult CancelInternal();
+
+  nsresult IsSecure(bool* aValue);
+
+  RefPtr<WebSocket> mWebSocket;
+
+  nsCOMPtr<nsIWebSocketChannel> mChannel;
+
+  bool mIsServerSide;  // True if we're implementing the server side of a
+                       // websocket connection
+
+  bool mSecure;  // if true it is using SSL and the wss scheme,
+                 // otherwise it is using the ws scheme with no SSL
+
+  bool mOnCloseScheduled;
+  bool mFailed;
+  Atomic<bool> mDisconnectingOrDisconnected;
+
+  // Set attributes of DOM 'onclose' message
+  bool mCloseEventWasClean;
+  nsString mCloseEventReason;
+  uint16_t mCloseEventCode;
+
+  nsCString mAsciiHost;  // hostname
+  uint32_t mPort;
+  nsCString mResource;  // [filepath[?query]]
+  nsString mUTF16Origin;
+
+  nsCString mURI;
+  nsCString mRequestedProtocolList;
+
+  nsWeakPtr mOriginDocument;
+
+  // Web Socket owner information:
+  // - the script file name, UTF8 encoded.
+  // - source code line number and column number where the Web Socket object
+  //   was constructed.
+  // - the ID of the Web Socket owner window. Note that this may not
+  //   be the same as the inner window where the script lives.
+  //   e.g within iframes
+  // These attributes are used for error reporting.
+  nsCString mScriptFile;
+  uint32_t mScriptLine;
+  uint32_t mScriptColumn;
+  uint64_t mInnerWindowID;
+  bool mPrivateBrowsing;
+  bool mIsChromeContext;
+
+  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
+
+  nsWeakPtr mWeakLoadGroup;
+
+  bool mIsMainThread;
+
+  // This mutex protects mWorkerShuttingDown.
+  mozilla::Mutex mMutex;
+  bool mWorkerShuttingDown MOZ_GUARDED_BY(mMutex);
+
+  RefPtr<WebSocketEventService> mService;
+  nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
+
+  // For dispatching runnables to main thread.
+  nsCOMPtr<nsISerialEventTarget> mMainThreadEventTarget;
+
+  RefPtr<WebSocketImplProxy> mImplProxy;
+
+ private:
+  ~WebSocketImpl() {
+    MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread() == mIsMainThread ||
+                          mDisconnectingOrDisconnected);
+
+    // If we threw during Init we never called disconnect
+    if (!mDisconnectingOrDisconnected) {
+      Disconnect();
+    }
+  }
+};
+
+NS_IMPL_ISUPPORTS(WebSocketImplProxy, nsIObserver, nsISupportsWeakReference,
+                  nsIWebSocketImpl)
+
+NS_IMETHODIMP
+WebSocketImplProxy::Observe(nsISupports* aSubject, const char* aTopic,
+                            const char16_t* aData) {
+  if (!mOwner) {
+    return NS_OK;
+  }
+
+  return mOwner->Observe(aSubject, aTopic, aData);
+}
+
+NS_IMETHODIMP
+WebSocketImplProxy::SendMessage(const nsAString& aMessage) {
+  if (!mOwner) {
+    return NS_OK;
+  }
+
+  return mOwner->SendMessage(aMessage);
+}
+
+NS_IMPL_ISUPPORTS(WebSocketImpl, nsIInterfaceRequestor, nsIWebSocketListener,
+                  nsIObserver, nsIRequest, nsIEventTarget, nsISerialEventTarget,
+                  nsIWebSocketImpl)
+
+class CallDispatchConnectionCloseEvents final : public DiscardableRunnable {
+ public:
+  explicit CallDispatchConnectionCloseEvents(WebSocketImpl* aWebSocketImpl)
+      : DiscardableRunnable("dom::CallDispatchConnectionCloseEvents"),
+        mWebSocketImpl(aWebSocketImpl) {
+    aWebSocketImpl->AssertIsOnTargetThread();
+  }
+
+  NS_IMETHOD Run() override {
+    mWebSocketImpl->AssertIsOnTargetThread();
+    mWebSocketImpl->DispatchConnectionCloseEvents();
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<WebSocketImpl> mWebSocketImpl;
+};
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl
+//-----------------------------------------------------------------------------
+
+namespace {
+
+class PrintErrorOnConsoleRunnable final : public WorkerMainThreadRunnable {
+ public:
+  PrintErrorOnConsoleRunnable(WebSocketImpl* aImpl, const char* aBundleURI,
+                              const char* aError,
+                              nsTArray<nsString>&& aFormatStrings)
+      : WorkerMainThreadRunnable(aImpl->mWorkerRef->Private(),
+                                 "WebSocket :: print error on console"_ns),
+        mImpl(aImpl),
+        mBundleURI(aBundleURI),
+        mError(aError),
+        mFormatStrings(std::move(aFormatStrings)) {}
+
+  bool MainThreadRun() override {
+    mImpl->PrintErrorOnConsole(mBundleURI, mError, std::move(mFormatStrings));
+    return true;
+  }
+
+ private:
+  // Raw pointer because this runnable is sync.
+  WebSocketImpl* mImpl;
+
+  const char* mBundleURI;
+  const char* mError;
+  nsTArray<nsString> mFormatStrings;
+};
+
+}  // namespace
+
+void WebSocketImpl::PrintErrorOnConsole(const char* aBundleURI,
+                                        const char* aError,
+                                        nsTArray<nsString>&& aFormatStrings) {
+  // This method must run on the main thread.
+
+  if (!NS_IsMainThread()) {
+    MOZ_ASSERT(mWorkerRef);
+
+    RefPtr<PrintErrorOnConsoleRunnable> runnable =
+        new PrintErrorOnConsoleRunnable(this, aBundleURI, aError,
+                                        std::move(aFormatStrings));
+    ErrorResult rv;
+    runnable->Dispatch(Killing, rv);
+    // XXXbz this seems totally broken.  We should be propagating this out, but
+    // none of our callers really propagate anything usefully.  Come to think of
+    // it, why is this a syncrunnable anyway?  Can't this be a fire-and-forget
+    // runnable??
+    rv.SuppressException();
+    return;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+      do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIStringBundle> strBundle;
+  rv = bundleService->CreateBundle(aBundleURI, getter_AddRefs(strBundle));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIConsoleService> console(
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIScriptError> errorObject(
+      do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // Localize the error message
+  nsAutoString message;
+  if (!aFormatStrings.IsEmpty()) {
+    rv = strBundle->FormatStringFromName(aError, aFormatStrings, message);
+  } else {
+    rv = strBundle->GetStringFromName(aError, message);
+  }
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  if (mInnerWindowID) {
+    rv = errorObject->InitWithWindowID(
+        message, NS_ConvertUTF8toUTF16(mScriptFile), u""_ns, mScriptLine,
+        mScriptColumn, nsIScriptError::errorFlag, "Web Socket"_ns,
+        mInnerWindowID);
+  } else {
+    rv =
+        errorObject->Init(message, NS_ConvertUTF8toUTF16(mScriptFile), u""_ns,
+                          mScriptLine, mScriptColumn, nsIScriptError::errorFlag,
+                          "Web Socket"_ns, mPrivateBrowsing, mIsChromeContext);
+  }
+
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // print the error message directly to the JS console
+  rv = console->LogMessage(errorObject);
+  NS_ENSURE_SUCCESS_VOID(rv);
+}
+
+namespace {
+
+class CancelWebSocketRunnable final : public Runnable {
+ public:
+  CancelWebSocketRunnable(nsIWebSocketChannel* aChannel, uint16_t aReasonCode,
+                          const nsACString& aReasonString)
+      : Runnable("dom::CancelWebSocketRunnable"),
+        mChannel(aChannel),
+        mReasonCode(aReasonCode),
+        mReasonString(aReasonString) {}
+
+  NS_IMETHOD Run() override {
+    nsresult rv = mChannel->Close(mReasonCode, mReasonString);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to dispatch the close message");
+    }
+    return NS_OK;
+  }
+
+ private:
+  nsCOMPtr<nsIWebSocketChannel> mChannel;
+  uint16_t mReasonCode;
+  nsCString mReasonString;
+};
+
+class MOZ_STACK_CLASS MaybeDisconnect {
+ public:
+  explicit MaybeDisconnect(WebSocketImpl* aImpl) : mImpl(aImpl) {}
+
+  ~MaybeDisconnect() {
+    bool toDisconnect = false;
+
+    {
+      MutexAutoLock lock(mImpl->mMutex);
+      toDisconnect = mImpl->mWorkerShuttingDown;
+    }
+
+    if (toDisconnect) {
+      mImpl->Disconnect();
+    }
+  }
+
+ private:
+  WebSocketImpl* mImpl;
+};
+
+class CloseConnectionRunnable final : public Runnable {
+ public:
+  CloseConnectionRunnable(WebSocketImpl* aImpl, uint16_t aReasonCode,
+                          const nsACString& aReasonString)
+      : Runnable("dom::CloseConnectionRunnable"),
+        mImpl(aImpl),
+        mReasonCode(aReasonCode),
+        mReasonString(aReasonString) {}
+
+  NS_IMETHOD Run() override {
+    return mImpl->CloseConnection(mReasonCode, mReasonString);
+  }
+
+ private:
+  RefPtr<WebSocketImpl> mImpl;
+  uint16_t mReasonCode;
+  const nsCString mReasonString;
+};
+
+}  // namespace
+
+nsresult WebSocketImpl::CloseConnection(uint16_t aReasonCode,
+                                        const nsACString& aReasonString) {
+  if (!IsTargetThread()) {
+    nsCOMPtr<nsIRunnable> runnable =
+        new CloseConnectionRunnable(this, aReasonCode, aReasonString);
+    return Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
+  }
+
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  // If this method is called because the worker is going away, we will not
+  // receive the OnStop() method and we have to disconnect the WebSocket and
+  // release the ThreadSafeWorkerRef.
+  MaybeDisconnect md(this);
+
+  uint16_t readyState = mWebSocket->ReadyState();
+  if (readyState == WebSocket::CLOSING || readyState == WebSocket::CLOSED) {
+    return NS_OK;
+  }
+
+  // The common case...
+  if (mChannel) {
+    mWebSocket->SetReadyState(WebSocket::CLOSING);
+
+    // The channel has to be closed on the main-thread.
+
+    if (NS_IsMainThread()) {
+      return mChannel->Close(aReasonCode, aReasonString);
+    }
+
+    RefPtr<CancelWebSocketRunnable> runnable =
+        new CancelWebSocketRunnable(mChannel, aReasonCode, aReasonString);
+    return NS_DispatchToMainThread(runnable);
+  }
+
+  // No channel, but not disconnected: canceled or failed early
+  MOZ_ASSERT(readyState == WebSocket::CONNECTING,
+             "Should only get here for early websocket cancel/error");
+
+  // Server won't be sending us a close code, so use what's passed in here.
+  mCloseEventCode = aReasonCode;
+  CopyUTF8toUTF16(aReasonString, mCloseEventReason);
+
+  mWebSocket->SetReadyState(WebSocket::CLOSING);
+
+  ScheduleConnectionCloseEvents(
+      nullptr, (aReasonCode == nsIWebSocketChannel::CLOSE_NORMAL ||
+                aReasonCode == nsIWebSocketChannel::CLOSE_GOING_AWAY)
+                   ? NS_OK
+                   : NS_ERROR_FAILURE);
+
+  return NS_OK;
+}
+
+nsresult WebSocketImpl::ConsoleError() {
+  AssertIsOnTargetThread();
+
+  {
+    MutexAutoLock lock(mMutex);
+    if (mWorkerShuttingDown) {
+      // Too late to report anything, bail out.
+      return NS_OK;
+    }
+  }
+
+  nsTArray<nsString> formatStrings;
+  CopyUTF8toUTF16(mURI, *formatStrings.AppendElement());
+
+  if (mWebSocket->ReadyState() < WebSocket::OPEN) {
+    PrintErrorOnConsole("chrome://global/locale/appstrings.properties",
+                        "connectionFailure", std::move(formatStrings));
+  } else {
+    PrintErrorOnConsole("chrome://global/locale/appstrings.properties",
+                        "netInterrupt", std::move(formatStrings));
+  }
+  /// todo some specific errors - like for message too large
+  return NS_OK;
+}
+
+void WebSocketImpl::FailConnection(uint16_t aReasonCode,
+                                   const nsACString& aReasonString) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return;
+  }
+
+  ConsoleError();
+  mFailed = true;
+  CloseConnection(aReasonCode, aReasonString);
+
+  if (NS_IsMainThread() && mImplProxy) {
+    mImplProxy->Disconnect();
+    mImplProxy = nullptr;
+  }
+}
+
+namespace {
+
+class DisconnectInternalRunnable final : public WorkerMainThreadRunnable {
+ public:
+  explicit DisconnectInternalRunnable(WebSocketImpl* aImpl)
+      : WorkerMainThreadRunnable(GetCurrentThreadWorkerPrivate(),
+                                 "WebSocket :: disconnect"_ns),
+        mImpl(aImpl) {}
+
+  bool MainThreadRun() override {
+    mImpl->DisconnectInternal();
+    return true;
+  }
+
+ private:
+  // A raw pointer because this runnable is sync.
+  WebSocketImpl* mImpl;
+};
+
+}  // namespace
+
+void WebSocketImpl::Disconnect() {
+  MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread() == mIsMainThread);
+
+  if (mDisconnectingOrDisconnected) {
+    return;
+  }
+
+  // DontKeepAliveAnyMore() and DisconnectInternal() can release the object. So
+  // hold a reference to this until the end of the method.
+  RefPtr<WebSocketImpl> kungfuDeathGrip = this;
+
+  // Disconnect can be called from some control event (such as a callback from
+  // StrongWorkerRef). This will be schedulated before any other sync/async
+  // runnable. In order to prevent some double Disconnect() calls, we use this
+  // boolean.
+  mDisconnectingOrDisconnected = true;
+
+  // DisconnectInternal touches observers and nsILoadGroup and it must run on
+  // the main thread.
+
+  if (NS_IsMainThread()) {
+    DisconnectInternal();
+
+    // If we haven't called WebSocket::DisconnectFromOwner yet, update
+    // web socket count here.
+    if (mWebSocket->GetOwner()) {
+      mWebSocket->GetOwner()->UpdateWebSocketCount(-1);
+    }
+  } else {
+    RefPtr<DisconnectInternalRunnable> runnable =
+        new DisconnectInternalRunnable(this);
+    ErrorResult rv;
+    runnable->Dispatch(Killing, rv);
+    // XXXbz this seems totally broken.  We should be propagating this out, but
+    // where to, exactly?
+    rv.SuppressException();
+  }
+
+  NS_ReleaseOnMainThread("WebSocketImpl::mChannel", mChannel.forget());
+  NS_ReleaseOnMainThread("WebSocketImpl::mService", mService.forget());
+
+  mWebSocket->DontKeepAliveAnyMore();
+  mWebSocket->mImpl = nullptr;
+
+  if (mWorkerRef) {
+    UnregisterWorkerRef();
+  }
+
+  // We want to release the WebSocket in the correct thread.
+  mWebSocket = nullptr;
+}
+
+void WebSocketImpl::DisconnectInternal() {
+  AssertIsOnMainThread();
+
+  nsCOMPtr<nsILoadGroup> loadGroup = do_QueryReferent(mWeakLoadGroup);
+  if (loadGroup) {
+    loadGroup->RemoveRequest(this, nullptr, NS_OK);
+    // mWeakLoadGroup has to be release on main-thread because WeakReferences
+    // are not thread-safe.
+    mWeakLoadGroup = nullptr;
+  }
+
+  if (!mWorkerRef) {
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (os) {
+      os->RemoveObserver(mImplProxy, DOM_WINDOW_DESTROYED_TOPIC);
+      os->RemoveObserver(mImplProxy, DOM_WINDOW_FROZEN_TOPIC);
+    }
+  }
+
+  if (mImplProxy) {
+    mImplProxy->Disconnect();
+    mImplProxy = nullptr;
+  }
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl::nsIWebSocketImpl
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+WebSocketImpl::SendMessage(const nsAString& aMessage) {
+  nsString message(aMessage);
+  nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction(
+      "WebSocketImpl::SendMessage",
+      [self = RefPtr<WebSocketImpl>(this), message = std::move(message)]() {
+        ErrorResult IgnoredErrorResult;
+        self->mWebSocket->Send(message, IgnoredErrorResult);
+      });
+  return Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl::nsIWebSocketListener methods:
+//-----------------------------------------------------------------------------
+
+nsresult WebSocketImpl::DoOnMessageAvailable(const nsACString& aMsg,
+                                             bool isBinary) const {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  int16_t readyState = mWebSocket->ReadyState();
+  if (readyState == WebSocket::CLOSED) {
+    NS_ERROR("Received message after CLOSED");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  if (readyState == WebSocket::OPEN) {
+    // Dispatch New Message
+    nsresult rv = mWebSocket->CreateAndDispatchMessageEvent(aMsg, isBinary);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to dispatch the message event");
+    }
+
+    return NS_OK;
+  }
+
+  // CLOSING should be the only other state where it's possible to get msgs
+  // from channel: Spec says to drop them.
+  MOZ_ASSERT(readyState == WebSocket::CLOSING,
+             "Received message while CONNECTING or CLOSED");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnMessageAvailable(nsISupports* aContext,
+                                  const nsACString& aMsg) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  return DoOnMessageAvailable(aMsg, false);
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnBinaryMessageAvailable(nsISupports* aContext,
+                                        const nsACString& aMsg) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  return DoOnMessageAvailable(aMsg, true);
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnStart(nsISupports* aContext) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  int16_t readyState = mWebSocket->ReadyState();
+
+  // This is the only function that sets OPEN, and should be called only once
+  MOZ_ASSERT(readyState != WebSocket::OPEN,
+             "readyState already OPEN! OnStart called twice?");
+
+  // Nothing to do if we've already closed/closing
+  if (readyState != WebSocket::CONNECTING) {
+    return NS_OK;
+  }
+
+  // Attempt to kill "ghost" websocket: but usually too early for check to fail
+  nsresult rv = mWebSocket->CheckCurrentGlobalCorrectness();
+  if (NS_FAILED(rv)) {
+    CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
+    return rv;
+  }
+
+  if (!mRequestedProtocolList.IsEmpty()) {
+    rv = mChannel->GetProtocol(mWebSocket->mEstablishedProtocol);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  rv = mChannel->GetExtensions(mWebSocket->mEstablishedExtensions);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  UpdateURI();
+
+  mWebSocket->SetReadyState(WebSocket::OPEN);
+
+  mService->WebSocketOpened(
+      mChannel->Serial(), mInnerWindowID, mWebSocket->mEffectiveURL,
+      mWebSocket->mEstablishedProtocol, mWebSocket->mEstablishedExtensions,
+      mChannel->HttpChannelId());
+
+  // Let's keep the object alive because the webSocket can be CCed in the
+  // onopen callback.
+  RefPtr<WebSocket> webSocket = mWebSocket;
+
+  // Call 'onopen'
+  rv = webSocket->CreateAndDispatchSimpleEvent(OPEN_EVENT_STRING);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to dispatch the open event");
+  }
+
+  webSocket->UpdateMustKeepAlive();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnStop(nsISupports* aContext, nsresult aStatusCode) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  // We can be CONNECTING here if connection failed.
+  // We can be OPEN if we have encountered a fatal protocol error
+  // We can be CLOSING if close() was called and/or server initiated close.
+  MOZ_ASSERT(mWebSocket->ReadyState() != WebSocket::CLOSED,
+             "Shouldn't already be CLOSED when OnStop called");
+
+  return ScheduleConnectionCloseEvents(aContext, aStatusCode);
+}
+
+nsresult WebSocketImpl::ScheduleConnectionCloseEvents(nsISupports* aContext,
+                                                      nsresult aStatusCode) {
+  AssertIsOnTargetThread();
+
+  // no-op if some other code has already initiated close event
+  if (!mOnCloseScheduled) {
+    mCloseEventWasClean = NS_SUCCEEDED(aStatusCode);
+
+    if (aStatusCode == NS_BASE_STREAM_CLOSED) {
+      // don't generate an error event just because of an unclean close
+      aStatusCode = NS_OK;
+    }
+
+    if (aStatusCode == NS_ERROR_NET_INADEQUATE_SECURITY) {
+      // TLS negotiation failed so we need to set status code to 1015.
+      mCloseEventCode = 1015;
+    }
+
+    if (NS_FAILED(aStatusCode)) {
+      ConsoleError();
+      mFailed = true;
+    }
+
+    mOnCloseScheduled = true;
+
+    NS_DispatchToCurrentThread(new CallDispatchConnectionCloseEvents(this));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnAcknowledge(nsISupports* aContext, uint32_t aSize) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  MOZ_RELEASE_ASSERT(mWebSocket->mOutgoingBufferedAmount.isValid());
+  if (aSize > mWebSocket->mOutgoingBufferedAmount.value()) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  CheckedUint64 outgoingBufferedAmount = mWebSocket->mOutgoingBufferedAmount;
+  outgoingBufferedAmount -= aSize;
+  if (!outgoingBufferedAmount.isValid()) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mWebSocket->mOutgoingBufferedAmount = outgoingBufferedAmount;
+  MOZ_RELEASE_ASSERT(mWebSocket->mOutgoingBufferedAmount.isValid());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnServerClose(nsISupports* aContext, uint16_t aCode,
+                             const nsACString& aReason) {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  int16_t readyState = mWebSocket->ReadyState();
+
+  MOZ_ASSERT(readyState != WebSocket::CONNECTING,
+             "Received server close before connected?");
+  MOZ_ASSERT(readyState != WebSocket::CLOSED,
+             "Received server close after already closed!");
+
+  // store code/string for onclose DOM event
+  mCloseEventCode = aCode;
+  CopyUTF8toUTF16(aReason, mCloseEventReason);
+
+  if (readyState == WebSocket::OPEN) {
+    // Server initiating close.
+    // RFC 6455, 5.5.1: "When sending a Close frame in response, the endpoint
+    // typically echos the status code it received".
+    // But never send certain codes, per section 7.4.1
+    if (aCode == 1005 || aCode == 1006 || aCode == 1015) {
+      CloseConnection(0, ""_ns);
+    } else {
+      CloseConnection(aCode, aReason);
+    }
+  } else {
+    // We initiated close, and server has replied: OnStop does rest of the work.
+    MOZ_ASSERT(readyState == WebSocket::CLOSING, "unknown state");
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::OnError() {
+  if (!IsTargetThread()) {
+    return Dispatch(
+        NS_NewRunnableFunction("dom::FailConnectionRunnable",
+                               [self = RefPtr{this}]() {
+                                 self->FailConnection(
+                                     nsIWebSocketChannel::CLOSE_ABNORMAL);
+                               }),
+        NS_DISPATCH_NORMAL);
+  }
+
+  AssertIsOnTargetThread();
+  FailConnection(nsIWebSocketChannel::CLOSE_ABNORMAL);
+  return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl::nsIInterfaceRequestor
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+WebSocketImpl::GetInterface(const nsIID& aIID, void** aResult) {
+  AssertIsOnMainThread();
+
+  if (!mWebSocket || mWebSocket->ReadyState() == WebSocket::CLOSED) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||
+      aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {
+    nsCOMPtr<nsPIDOMWindowInner> win = mWebSocket->GetWindowIfCurrent();
+    if (!win) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    nsresult rv;
+    nsCOMPtr<nsIPromptFactory> wwatch =
+        do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsPIDOMWindowOuter> outerWindow = win->GetOuterWindow();
+    return wwatch->GetPrompt(outerWindow, aIID, aResult);
+  }
+
+  return QueryInterface(aIID, aResult);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WebSocket
+////////////////////////////////////////////////////////////////////////////////
+
+WebSocket::WebSocket(nsIGlobalObject* aGlobal)
+    : DOMEventTargetHelper(aGlobal),
+      mIsMainThread(true),
+      mKeepingAlive(false),
+      mCheckMustKeepAlive(true),
+      mOutgoingBufferedAmount(0),
+      mBinaryType(dom::BinaryType::Blob),
+      mMutex("WebSocket::mMutex"),
+      mReadyState(CONNECTING) {
+  MOZ_ASSERT(aGlobal);
+
+  mImpl = new WebSocketImpl(this);
+  mIsMainThread = mImpl->mIsMainThread;
+}
+
+WebSocket::~WebSocket() = default;
+
+mozilla::Maybe<EventCallbackDebuggerNotificationType>
+WebSocket::GetDebuggerNotificationType() const {
+  return mozilla::Some(EventCallbackDebuggerNotificationType::Websocket);
+}
+
+JSObject* WebSocket::WrapObject(JSContext* cx,
+                                JS::Handle<JSObject*> aGivenProto) {
+  return WebSocket_Binding::Wrap(cx, this, aGivenProto);
+}
+
+//---------------------------------------------------------------------------
+// WebIDL
+//---------------------------------------------------------------------------
+
+// Constructor:
+already_AddRefed<WebSocket> WebSocket::Constructor(
+    const GlobalObject& aGlobal, const nsAString& aUrl,
+    const StringOrStringSequence& aProtocols, ErrorResult& aRv) {
+  if (aProtocols.IsStringSequence()) {
+    return WebSocket::ConstructorCommon(
+        aGlobal, aUrl, aProtocols.GetAsStringSequence(), nullptr, ""_ns, aRv);
+  }
+
+  Sequence<nsString> protocols;
+  if (!protocols.AppendElement(aProtocols.GetAsString(), fallible)) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return nullptr;
+  }
+
+  return WebSocket::ConstructorCommon(aGlobal, aUrl, protocols, nullptr, ""_ns,
+                                      aRv);
+}
+
+already_AddRefed<WebSocket> WebSocket::CreateServerWebSocket(
+    const GlobalObject& aGlobal, const nsAString& aUrl,
+    const Sequence<nsString>& aProtocols,
+    nsITransportProvider* aTransportProvider,
+    const nsAString& aNegotiatedExtensions, ErrorResult& aRv) {
+  return WebSocket::ConstructorCommon(
+      aGlobal, aUrl, aProtocols, aTransportProvider,
+      NS_ConvertUTF16toUTF8(aNegotiatedExtensions), aRv);
+}
+
+namespace {
+
+// This class is used to clear any exception.
+class MOZ_STACK_CLASS ClearException {
+ public:
+  explicit ClearException(JSContext* aCx) : mCx(aCx) {}
+
+  ~ClearException() { JS_ClearPendingException(mCx); }
+
+ private:
+  JSContext* mCx;
+};
+
+class WebSocketMainThreadRunnable : public WorkerMainThreadRunnable {
+ public:
+  WebSocketMainThreadRunnable(WorkerPrivate* aWorkerPrivate,
+                              const nsACString& aTelemetryKey)
+      : WorkerMainThreadRunnable(aWorkerPrivate, aTelemetryKey) {
+    MOZ_ASSERT(aWorkerPrivate);
+    aWorkerPrivate->AssertIsOnWorkerThread();
+  }
+
+  bool MainThreadRun() override {
+    AssertIsOnMainThread();
+
+    // Walk up to our containing page
+    WorkerPrivate* wp = mWorkerPrivate;
+    while (wp->GetParent()) {
+      wp = wp->GetParent();
+    }
+
+    nsPIDOMWindowInner* window = wp->GetWindow();
+    if (window) {
+      return InitWithWindow(window);
+    }
+
+    return InitWindowless(wp);
+  }
+
+ protected:
+  virtual bool InitWithWindow(nsPIDOMWindowInner* aWindow) = 0;
+
+  virtual bool InitWindowless(WorkerPrivate* aTopLevelWorkerPrivate) = 0;
+};
+
+class InitRunnable final : public WebSocketMainThreadRunnable {
+ public:
+  InitRunnable(WorkerPrivate* aWorkerPrivate, WebSocketImpl* aImpl,
+               const Maybe<mozilla::dom::ClientInfo>& aClientInfo,
+               bool aIsServerSide, const nsAString& aURL,
+               nsTArray<nsString>& aProtocolArray,
+               const nsACString& aScriptFile, uint32_t aScriptLine,
+               uint32_t aScriptColumn)
+      : WebSocketMainThreadRunnable(aWorkerPrivate, "WebSocket :: init"_ns),
+        mImpl(aImpl),
+        mClientInfo(aClientInfo),
+        mIsServerSide(aIsServerSide),
+        mURL(aURL),
+        mProtocolArray(aProtocolArray),
+        mScriptFile(aScriptFile),
+        mScriptLine(aScriptLine),
+        mScriptColumn(aScriptColumn),
+        mErrorCode(NS_OK) {
+    MOZ_ASSERT(mWorkerPrivate);
+    mWorkerPrivate->AssertIsOnWorkerThread();
+  }
+
+  nsresult ErrorCode() const { return mErrorCode; }
+
+ protected:
+  virtual bool InitWithWindow(nsPIDOMWindowInner* aWindow) override {
+    AutoJSAPI jsapi;
+    if (NS_WARN_IF(!jsapi.Init(aWindow))) {
+      mErrorCode = NS_ERROR_FAILURE;
+      return true;
+    }
+
+    ClearException ce(jsapi.cx());
+
+    Document* doc = aWindow->GetExtantDoc();
+    if (!doc) {
+      mErrorCode = NS_ERROR_FAILURE;
+      return true;
+    }
+
+    mErrorCode = mImpl->Init(
+        jsapi.cx(), mWorkerPrivate->GetPrincipal()->SchemeIs("https"),
+        doc->NodePrincipal(), mClientInfo, mWorkerPrivate->CSPEventListener(),
+        mIsServerSide, mURL, mProtocolArray, mScriptFile, mScriptLine,
+        mScriptColumn);
+    return true;
+  }
+
+  virtual bool InitWindowless(WorkerPrivate* aTopLevelWorkerPrivate) override {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(aTopLevelWorkerPrivate && !aTopLevelWorkerPrivate->GetWindow());
+
+    mErrorCode =
+        mImpl->Init(nullptr, mWorkerPrivate->GetPrincipal()->SchemeIs("https"),
+                    aTopLevelWorkerPrivate->GetPrincipal(), mClientInfo,
+                    mWorkerPrivate->CSPEventListener(), mIsServerSide, mURL,
+                    mProtocolArray, mScriptFile, mScriptLine, mScriptColumn);
+    return true;
+  }
+
+  // Raw pointer. This worker runnable runs synchronously.
+  WebSocketImpl* mImpl;
+
+  Maybe<ClientInfo> mClientInfo;
+  bool mIsServerSide;
+  const nsAString& mURL;
+  nsTArray<nsString>& mProtocolArray;
+  nsCString mScriptFile;
+  uint32_t mScriptLine;
+  uint32_t mScriptColumn;
+  nsresult mErrorCode;
+};
+
+class ConnectRunnable final : public WebSocketMainThreadRunnable {
+ public:
+  ConnectRunnable(WorkerPrivate* aWorkerPrivate, WebSocketImpl* aImpl)
+      : WebSocketMainThreadRunnable(aWorkerPrivate, "WebSocket :: init"_ns),
+        mImpl(aImpl),
+        mConnectionFailed(true) {
+    MOZ_ASSERT(mWorkerPrivate);
+    mWorkerPrivate->AssertIsOnWorkerThread();
+  }
+
+  bool ConnectionFailed() const { return mConnectionFailed; }
+
+ protected:
+  virtual bool InitWithWindow(nsPIDOMWindowInner* aWindow) override {
+    Document* doc = aWindow->GetExtantDoc();
+    if (!doc) {
+      return true;
+    }
+
+    mConnectionFailed = NS_FAILED(mImpl->InitializeConnection(
+        doc->NodePrincipal(), mWorkerPrivate->CookieJarSettings()));
+    return true;
+  }
+
+  virtual bool InitWindowless(WorkerPrivate* aTopLevelWorkerPrivate) override {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(aTopLevelWorkerPrivate && !aTopLevelWorkerPrivate->GetWindow());
+
+    mConnectionFailed = NS_FAILED(
+        mImpl->InitializeConnection(aTopLevelWorkerPrivate->GetPrincipal(),
+                                    mWorkerPrivate->CookieJarSettings()));
+    return true;
+  }
+
+  // Raw pointer. This worker runnable runs synchronously.
+  WebSocketImpl* mImpl;
+
+  bool mConnectionFailed;
+};
+
+class AsyncOpenRunnable final : public WebSocketMainThreadRunnable {
+ public:
+  explicit AsyncOpenRunnable(WebSocketImpl* aImpl,
+                             UniquePtr<SerializedStackHolder> aOriginStack)
+      : WebSocketMainThreadRunnable(aImpl->mWorkerRef->Private(),
+                                    "WebSocket :: AsyncOpen"_ns),
+        mImpl(aImpl),
+        mOriginStack(std::move(aOriginStack)),
+        mErrorCode(NS_OK) {
+    MOZ_ASSERT(mWorkerPrivate);
+    mWorkerPrivate->AssertIsOnWorkerThread();
+  }
+
+  nsresult ErrorCode() const { return mErrorCode; }
+
+ protected:
+  virtual bool InitWithWindow(nsPIDOMWindowInner* aWindow) override {
+    AssertIsOnMainThread();
+    MOZ_ASSERT(aWindow);
+
+    Document* doc = aWindow->GetExtantDoc();
+    if (!doc) {
+      mErrorCode = NS_ERROR_FAILURE;
+      return true;
+    }
+
+    nsCOMPtr<nsIPrincipal> principal = doc->PartitionedPrincipal();
+    if (!principal) {
+      mErrorCode = NS_ERROR_FAILURE;
+      return true;
+    }
+
+    uint64_t windowID = 0;
+    if (WindowContext* wc = aWindow->GetWindowContext()) {
+      windowID = wc->InnerWindowId();
+    }
+
+    mErrorCode = mImpl->AsyncOpen(principal, windowID, nullptr, ""_ns,
+                                  std::move(mOriginStack));
+    return true;
+  }
+
+  virtual bool InitWindowless(WorkerPrivate* aTopLevelWorkerPrivate) override {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(aTopLevelWorkerPrivate && !aTopLevelWorkerPrivate->GetWindow());
+
+    mErrorCode =
+        mImpl->AsyncOpen(aTopLevelWorkerPrivate->GetPartitionedPrincipal(), 0,
+                         nullptr, ""_ns, nullptr);
+    return true;
+  }
+
+ private:
+  // Raw pointer. This worker runs synchronously.
+  WebSocketImpl* mImpl;
+
+  UniquePtr<SerializedStackHolder> mOriginStack;
+
+  nsresult mErrorCode;
+};
+
+}  // namespace
+
+// Check a protocol entry contains only valid characters
+bool WebSocket::IsValidProtocolString(const nsString& aValue) {
+  // RFC 6455 (4.1): "not including separator characters as defined in RFC 2616"
+  const char16_t illegalCharacters[] = {0x28, 0x29, 0x3C, 0x3E, 0x40, 0x2C,
+                                        0x3B, 0x3A, 0x5C, 0x22, 0x2F, 0x5B,
+                                        0x5D, 0x3F, 0x3D, 0x7B, 0x7D};
+
+  // Cannot be empty string
+  if (aValue.IsEmpty()) {
+    return false;
+  }
+
+  const auto* start = aValue.BeginReading();
+  const auto* end = aValue.EndReading();
+
+  auto charFilter = [&](char16_t c) {
+    // RFC 6455 (4.1 P18): "in the range U+0021 to U+007E"
+    if (c < 0x21 || c > 0x7E) {
+      return true;
+    }
+
+    return std::find(std::begin(illegalCharacters), std::end(illegalCharacters),
+                     c) != std::end(illegalCharacters);
+  };
+
+  return std::find_if(start, end, charFilter) == end;
+}
+
+already_AddRefed<WebSocket> WebSocket::ConstructorCommon(
+    const GlobalObject& aGlobal, const nsAString& aUrl,
+    const Sequence<nsString>& aProtocols,
+    nsITransportProvider* aTransportProvider,
+    const nsACString& aNegotiatedExtensions, ErrorResult& aRv) {
+  MOZ_ASSERT_IF(!aTransportProvider, aNegotiatedExtensions.IsEmpty());
+  nsCOMPtr<nsIPrincipal> principal;
+  nsCOMPtr<nsIPrincipal> partitionedPrincipal;
+
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+  if (NS_WARN_IF(!global)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  if (NS_IsMainThread()) {
+    nsCOMPtr<nsIScriptObjectPrincipal> scriptPrincipal =
+        do_QueryInterface(aGlobal.GetAsSupports());
+    if (!scriptPrincipal) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
+    }
+
+    principal = scriptPrincipal->GetPrincipal();
+    partitionedPrincipal = scriptPrincipal->PartitionedPrincipal();
+    if (!principal || !partitionedPrincipal) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
+    }
+  }
+
+  nsTArray<nsString> protocolArray;
+
+  for (uint32_t index = 0, len = aProtocols.Length(); index < len; ++index) {
+    const nsString& protocolElement = aProtocols[index];
+
+    // Repeated protocols are not allowed
+    if (protocolArray.Contains(protocolElement)) {
+      aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+      return nullptr;
+    }
+
+    // Protocol string value must match constraints
+    if (!IsValidProtocolString(protocolElement)) {
+      aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+      return nullptr;
+    }
+
+    protocolArray.AppendElement(protocolElement);
+  }
+
+  RefPtr<WebSocket> webSocket = new WebSocket(global);
+  RefPtr<WebSocketImpl> webSocketImpl = webSocket->mImpl;
+
+  bool connectionFailed = true;
+
+  if (NS_IsMainThread()) {
+    // We're keeping track of all main thread web sockets to be able to
+    // avoid throttling timeouts when we have active web sockets.
+    if (webSocket->GetOwner()) {
+      webSocket->GetOwner()->UpdateWebSocketCount(1);
+    }
+
+    bool isSecure = principal->SchemeIs("https");
+    aRv = webSocketImpl->IsSecure(&isSecure);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    aRv = webSocketImpl->Init(aGlobal.Context(), isSecure, principal, Nothing(),
+                              nullptr, !!aTransportProvider, aUrl,
+                              protocolArray, ""_ns, 0, 0);
+
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    nsCOMPtr<Document> doc = webSocket->GetDocumentIfCurrent();
+
+    // the constructor should throw a SYNTAX_ERROR only if it fails to parse the
+    // url parameter, so don't throw if InitializeConnection fails, and call
+    // onerror/onclose asynchronously
+    connectionFailed = NS_FAILED(webSocketImpl->InitializeConnection(
+        principal, doc ? doc->CookieJarSettings() : nullptr));
+  } else {
+    WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+    MOZ_ASSERT(workerPrivate);
+
+    unsigned lineno, column;
+    JS::AutoFilename file;
+    if (!JS::DescribeScriptedCaller(aGlobal.Context(), &file, &lineno,
+                                    &column)) {
+      NS_WARNING("Failed to get line number and filename in workers.");
+    }
+
+    RefPtr<InitRunnable> runnable = new InitRunnable(
+        workerPrivate, webSocketImpl,
+        workerPrivate->GlobalScope()->GetClientInfo(), !!aTransportProvider,
+        aUrl, protocolArray, nsDependentCString(file.get()), lineno, column);
+    runnable->Dispatch(Canceling, aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    aRv = runnable->ErrorCode();
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    if (NS_WARN_IF(!webSocketImpl->RegisterWorkerRef(workerPrivate))) {
+      // The worker is shutting down.
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
+    }
+
+    RefPtr<ConnectRunnable> connectRunnable =
+        new ConnectRunnable(workerPrivate, webSocketImpl);
+    connectRunnable->Dispatch(Canceling, aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    connectionFailed = connectRunnable->ConnectionFailed();
+  }
+
+  // It can be that we have been already disconnected because the WebSocket is
+  // gone away while we where initializing the webSocket.
+  if (!webSocket->mImpl) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  // We don't return an error if the connection just failed. Instead we dispatch
+  // an event.
+  if (connectionFailed) {
+    webSocket->mImpl->FailConnection(nsIWebSocketChannel::CLOSE_ABNORMAL);
+  }
+
+  // If we don't have a channel, the connection is failed and onerror() will be
+  // called asynchrounsly.
+  if (!webSocket->mImpl->mChannel) {
+    return webSocket.forget();
+  }
+
+  class MOZ_STACK_CLASS ClearWebSocket {
+   public:
+    explicit ClearWebSocket(WebSocketImpl* aWebSocketImpl)
+        : mWebSocketImpl(aWebSocketImpl), mDone(false) {}
+
+    void Done() { mDone = true; }
+
+    ~ClearWebSocket() {
+      if (!mDone) {
+        mWebSocketImpl->mChannel = nullptr;
+        mWebSocketImpl->FailConnection(nsIWebSocketChannel::CLOSE_ABNORMAL);
+      }
+    }
+
+    WebSocketImpl* mWebSocketImpl;
+    bool mDone;
+  };
+
+  ClearWebSocket cws(webSocket->mImpl);
+
+  // This operation must be done on the correct thread. The rest must run on the
+  // main-thread.
+  aRv = webSocket->mImpl->mChannel->SetNotificationCallbacks(webSocket->mImpl);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (NS_IsMainThread()) {
+    MOZ_ASSERT(principal);
+    MOZ_ASSERT(partitionedPrincipal);
+
+    nsCOMPtr<nsPIDOMWindowInner> ownerWindow = do_QueryInterface(global);
+
+    UniquePtr<SerializedStackHolder> stack;
+    uint64_t windowID = 0;
+
+    if (ownerWindow) {
+      BrowsingContext* browsingContext = ownerWindow->GetBrowsingContext();
+      if (browsingContext && browsingContext->WatchedByDevTools()) {
+        stack = GetCurrentStackForNetMonitor(aGlobal.Context());
+      }
+
+      if (WindowContext* wc = ownerWindow->GetWindowContext()) {
+        windowID = wc->InnerWindowId();
+      }
+    }
+
+    aRv = webSocket->mImpl->AsyncOpen(partitionedPrincipal, windowID,
+                                      aTransportProvider, aNegotiatedExtensions,
+                                      std::move(stack));
+  } else {
+    MOZ_ASSERT(!aTransportProvider && aNegotiatedExtensions.IsEmpty(),
+               "not yet implemented");
+
+    UniquePtr<SerializedStackHolder> stack;
+    WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+    if (workerPrivate->IsWatchedByDevTools()) {
+      stack = GetCurrentStackForNetMonitor(aGlobal.Context());
+    }
+
+    RefPtr<AsyncOpenRunnable> runnable =
+        new AsyncOpenRunnable(webSocket->mImpl, std::move(stack));
+    runnable->Dispatch(Canceling, aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    aRv = runnable->ErrorCode();
+  }
+
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  // It can be that we have been already disconnected because the WebSocket is
+  // gone away while we where initializing the webSocket.
+  if (!webSocket->mImpl) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  // Let's inform devtools about this new active WebSocket.
+  webSocket->mImpl->mService->WebSocketCreated(
+      webSocket->mImpl->mChannel->Serial(), webSocket->mImpl->mInnerWindowID,
+      webSocket->mURI, webSocket->mImpl->mRequestedProtocolList);
+  cws.Done();
+
+  return webSocket.forget();
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(WebSocket)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WebSocket,
+                                                  DOMEventTargetHelper)
+  if (tmp->mImpl) {
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImpl->mChannel)
+  }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WebSocket, DOMEventTargetHelper)
+  if (tmp->mImpl) {
+    NS_IMPL_CYCLE_COLLECTION_UNLINK(mImpl->mChannel)
+    tmp->mImpl->Disconnect();
+    MOZ_ASSERT(!tmp->mImpl);
+  }
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+bool WebSocket::IsCertainlyAliveForCC() const { return mKeepingAlive; }
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WebSocket)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(WebSocket, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(WebSocket, DOMEventTargetHelper)
+
+void WebSocket::DisconnectFromOwner() {
+  // If we haven't called WebSocketImpl::Disconnect yet, update web
+  // socket count here.
+  if (NS_IsMainThread() && mImpl && !mImpl->mDisconnectingOrDisconnected &&
+      GetOwner()) {
+    GetOwner()->UpdateWebSocketCount(-1);
+  }
+
+  DOMEventTargetHelper::DisconnectFromOwner();
+
+  if (mImpl) {
+    mImpl->CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
+  }
+
+  DontKeepAliveAnyMore();
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl:: initialization
+//-----------------------------------------------------------------------------
+
+nsresult WebSocketImpl::Init(JSContext* aCx, bool aIsSecure,
+                             nsIPrincipal* aPrincipal,
+                             const Maybe<ClientInfo>& aClientInfo,
+                             nsICSPEventListener* aCSPEventListener,
+                             bool aIsServerSide, const nsAString& aURL,
+                             nsTArray<nsString>& aProtocolArray,
+                             const nsACString& aScriptFile,
+                             uint32_t aScriptLine, uint32_t aScriptColumn) {
+  AssertIsOnMainThread();
+  MOZ_ASSERT(aPrincipal);
+
+  mService = WebSocketEventService::GetOrCreate();
+
+  // We need to keep the implementation alive in case the init disconnects it
+  // because of some error.
+  RefPtr<WebSocketImpl> kungfuDeathGrip = this;
+
+  // Attempt to kill "ghost" websocket: but usually too early for check to fail
+  nsresult rv = mWebSocket->CheckCurrentGlobalCorrectness();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Shut down websocket if window is frozen or destroyed (only needed for
+  // "ghost" websockets--see bug 696085)
+  RefPtr<WebSocketImplProxy> proxy;
+  if (mIsMainThread) {
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (NS_WARN_IF(!os)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    proxy = new WebSocketImplProxy(this);
+    rv = os->AddObserver(proxy, DOM_WINDOW_DESTROYED_TOPIC, true);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = os->AddObserver(proxy, DOM_WINDOW_FROZEN_TOPIC, true);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (!mIsMainThread) {
+    mScriptFile = aScriptFile;
+    mScriptLine = aScriptLine;
+    mScriptColumn = aScriptColumn;
+  } else {
+    MOZ_ASSERT(aCx);
+
+    unsigned lineno, column;
+    JS::AutoFilename file;
+    if (JS::DescribeScriptedCaller(aCx, &file, &lineno, &column)) {
+      mScriptFile = file.get();
+      mScriptLine = lineno;
+      mScriptColumn = column;
+    }
+  }
+
+  mIsServerSide = aIsServerSide;
+
+  // If we don't have aCx, we are window-less, so we don't have a
+  // inner-windowID. This can happen in sharedWorkers and ServiceWorkers or in
+  // DedicateWorkers created by JSM.
+  if (aCx) {
+    if (nsPIDOMWindowInner* ownerWindow = mWebSocket->GetOwner()) {
+      mInnerWindowID = ownerWindow->WindowID();
+    }
+  }
+
+  mPrivateBrowsing = !!aPrincipal->OriginAttributesRef().mPrivateBrowsingId;
+  mIsChromeContext = aPrincipal->IsSystemPrincipal();
+
+  // parses the url
+  rv = ParseURL(aURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<Document> originDoc = mWebSocket->GetDocumentIfCurrent();
+  if (!originDoc) {
+    rv = mWebSocket->CheckCurrentGlobalCorrectness();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  mOriginDocument = do_GetWeakReference(originDoc);
+
+  if (!mIsServerSide) {
+    nsCOMPtr<nsIURI> uri;
+    {
+      nsresult rv = NS_NewURI(getter_AddRefs(uri), mURI);
+
+      // We crash here because we are sure that mURI is a valid URI, so either
+      // we are OOM'ing or something else bad is happening.
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        MOZ_CRASH();
+      }
+    }
+
+    // The 'real' nsHttpChannel of the websocket gets opened in the parent.
+    // Since we don't serialize the CSP within child and parent and also not
+    // the context, we have to perform content policy checks here instead of
+    // AsyncOpen().
+    // Please note that websockets can't follow redirects, hence there is no
+    // need to perform a CSP check after redirects.
+    nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
+        aPrincipal,  // loading principal
+        aPrincipal,  // triggering principal
+        originDoc, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
+        nsIContentPolicy::TYPE_WEBSOCKET, aClientInfo);
+
+    if (aCSPEventListener) {
+      secCheckLoadInfo->SetCspEventListener(aCSPEventListener);
+    }
+
+    int16_t shouldLoad = nsIContentPolicy::ACCEPT;
+    rv = NS_CheckContentLoadPolicy(uri, secCheckLoadInfo, ""_ns, &shouldLoad,
+                                   nsContentUtils::GetContentPolicy());
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (NS_CP_REJECTED(shouldLoad)) {
+      // Disallowed by content policy
+      return NS_ERROR_CONTENT_BLOCKED;
+    }
+
+    // If the HTTPS-Only mode is enabled, we need to upgrade the websocket
+    // connection from ws:// to wss:// and mark it as secure.
+    if (!mSecure && originDoc &&
+        !nsMixedContentBlocker::IsPotentiallyTrustworthyLoopbackURL(
+            originDoc->GetDocumentURI())) {
+      nsCOMPtr<nsIURI> uri;
+      nsresult rv = NS_NewURI(getter_AddRefs(uri), mURI);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // secCheckLoadInfo is only used for the triggering principal, so this
+      // is okay.
+      if (nsHTTPSOnlyUtils::ShouldUpgradeWebSocket(uri, secCheckLoadInfo)) {
+        mURI.ReplaceSubstring("ws://", "wss://");
+        if (NS_WARN_IF(mURI.Find("wss://") != 0)) {
+          return NS_OK;
+        }
+        mSecure = true;
+      }
+    }
+  }
+
+  // Potentially the page uses the CSP directive 'upgrade-insecure-requests'.
+  // In such a case we have to upgrade ws: to wss: and also update mSecure
+  // to reflect that upgrade. Please note that we can not upgrade from ws:
+  // to wss: before performing content policy checks because CSP needs to
+  // send reports in case the scheme is about to be upgraded.
+  if (!mIsServerSide && !mSecure && originDoc &&
+      originDoc->GetUpgradeInsecureRequests(false) &&
+      !nsMixedContentBlocker::IsPotentiallyTrustworthyLoopbackURL(
+          originDoc->GetDocumentURI())) {
+    // let's use the old specification before the upgrade for logging
+    AutoTArray<nsString, 2> params;
+    CopyUTF8toUTF16(mURI, *params.AppendElement());
+
+    // upgrade the request from ws:// to wss:// and mark as secure
+    mURI.ReplaceSubstring("ws://", "wss://");
+    if (NS_WARN_IF(mURI.Find("wss://") != 0)) {
+      return NS_OK;
+    }
+    mSecure = true;
+
+    params.AppendElement(u"wss"_ns);
+    CSP_LogLocalizedStr("upgradeInsecureRequest", params,
+                        u""_ns,  // aSourceFile
+                        u""_ns,  // aScriptSample
+                        0,       // aLineNumber
+                        0,       // aColumnNumber
+                        nsIScriptError::warningFlag,
+                        "upgradeInsecureRequest"_ns, mInnerWindowID,
+                        mPrivateBrowsing);
+  }
+
+  // Don't allow https:// to open ws://
+  if (!mIsServerSide && !mSecure &&
+      !Preferences::GetBool("network.websocket.allowInsecureFromHTTPS",
+                            false) &&
+      !nsMixedContentBlocker::IsPotentiallyTrustworthyLoopbackHost(
+          mAsciiHost)) {
+    if (aIsSecure) {
+      return NS_ERROR_DOM_SECURITY_ERR;
+    }
+  }
+
+  // Assign the sub protocol list and scan it for illegal values
+  for (uint32_t index = 0; index < aProtocolArray.Length(); ++index) {
+    if (!WebSocket::IsValidProtocolString(aProtocolArray[index])) {
+      return NS_ERROR_DOM_SYNTAX_ERR;
+    }
+
+    if (!mRequestedProtocolList.IsEmpty()) {
+      mRequestedProtocolList.AppendLiteral(", ");
+    }
+
+    AppendUTF16toUTF8(aProtocolArray[index], mRequestedProtocolList);
+  }
+
+  if (mIsMainThread) {
+    mImplProxy = std::move(proxy);
+  }
+  return NS_OK;
+}
+
+nsresult WebSocketImpl::AsyncOpen(
+    nsIPrincipal* aPrincipal, uint64_t aInnerWindowID,
+    nsITransportProvider* aTransportProvider,
+    const nsACString& aNegotiatedExtensions,
+    UniquePtr<SerializedStackHolder> aOriginStack) {
+  MOZ_ASSERT(NS_IsMainThread(), "Not running on main thread");
+  MOZ_ASSERT_IF(!aTransportProvider, aNegotiatedExtensions.IsEmpty());
+
+  nsCString asciiOrigin;
+  nsresult rv = aPrincipal->GetAsciiOrigin(asciiOrigin);
+  if (NS_FAILED(rv)) {
+    asciiOrigin.AssignLiteral("null");
+  }
+
+  if (aTransportProvider) {
+    rv = mChannel->SetServerParameters(aTransportProvider,
+                                       aNegotiatedExtensions);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  ToLowerCase(asciiOrigin);
+
+  nsCOMPtr<nsIURI> uri;
+  if (!aTransportProvider) {
+    rv = NS_NewURI(getter_AddRefs(uri), mURI);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  rv = mChannel->AsyncOpenNative(uri, asciiOrigin,
+                                 aPrincipal->OriginAttributesRef(),
+                                 aInnerWindowID, this, nullptr);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return NS_ERROR_CONTENT_BLOCKED;
+  }
+
+  NotifyNetworkMonitorAlternateStack(mChannel, std::move(aOriginStack));
+
+  mInnerWindowID = aInnerWindowID;
+
+  return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl methods:
+//-----------------------------------------------------------------------------
+
+class nsAutoCloseWS final {
+ public:
+  explicit nsAutoCloseWS(WebSocketImpl* aWebSocketImpl)
+      : mWebSocketImpl(aWebSocketImpl) {}
+
+  ~nsAutoCloseWS() {
+    if (!mWebSocketImpl->mChannel) {
+      mWebSocketImpl->CloseConnection(
+          nsIWebSocketChannel::CLOSE_INTERNAL_ERROR);
+    }
+  }
+
+ private:
+  RefPtr<WebSocketImpl> mWebSocketImpl;
+};
+
+nsresult WebSocketImpl::InitializeConnection(
+    nsIPrincipal* aPrincipal, nsICookieJarSettings* aCookieJarSettings) {
+  AssertIsOnMainThread();
+  MOZ_ASSERT(!mChannel, "mChannel should be null");
+
+  nsCOMPtr<nsIWebSocketChannel> wsChannel;
+  nsAutoCloseWS autoClose(this);
+  nsresult rv;
+
+  if (mSecure) {
+    wsChannel =
+        do_CreateInstance("@mozilla.org/network/protocol;1?name=wss", &rv);
+  } else {
+    wsChannel =
+        do_CreateInstance("@mozilla.org/network/protocol;1?name=ws", &rv);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // add ourselves to the document's load group and
+  // provide the http stack the loadgroup info too
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  rv = GetLoadGroup(getter_AddRefs(loadGroup));
+  if (loadGroup) {
+    rv = wsChannel->SetLoadGroup(loadGroup);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = loadGroup->AddRequest(this, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mWeakLoadGroup = do_GetWeakReference(loadGroup);
+  }
+
+  // manually adding loadinfo to the channel since it
+  // was not set during channel creation.
+  nsCOMPtr<Document> doc = do_QueryReferent(mOriginDocument);
+
+  // mOriginDocument has to be release on main-thread because WeakReferences
+  // are not thread-safe.
+  mOriginDocument = nullptr;
+
+  // The TriggeringPrincipal for websockets must always be a script.
+  // Let's make sure that the doc's principal (if a doc exists)
+  // and aPrincipal are same origin.
+  MOZ_ASSERT(!doc || doc->NodePrincipal()->Equals(aPrincipal));
+
+  rv = wsChannel->InitLoadInfoNative(
+      doc, doc ? doc->NodePrincipal() : aPrincipal, aPrincipal,
+      aCookieJarSettings,
+      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      nsIContentPolicy::TYPE_WEBSOCKET, 0);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+  if (!mRequestedProtocolList.IsEmpty()) {
+    rv = wsChannel->SetProtocol(mRequestedProtocolList);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(wsChannel);
+  NS_ENSURE_TRUE(rr, NS_ERROR_FAILURE);
+
+  rv = rr->RetargetDeliveryTo(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mChannel = wsChannel;
+
+  if (mIsMainThread) {
+    MOZ_ASSERT(mImplProxy);
+    mService->AssociateWebSocketImplWithSerialID(mImplProxy,
+                                                 mChannel->Serial());
+  }
+
+  if (mIsMainThread && doc) {
+    mMainThreadEventTarget = doc->EventTargetFor(TaskCategory::Other);
+  }
+
+  return NS_OK;
+}
+
+void WebSocketImpl::DispatchConnectionCloseEvents() {
+  AssertIsOnTargetThread();
+
+  if (mDisconnectingOrDisconnected) {
+    return;
+  }
+
+  mWebSocket->SetReadyState(WebSocket::CLOSED);
+
+  // Let's keep the object alive because the webSocket can be CCed in the
+  // onerror or in the onclose callback.
+  RefPtr<WebSocket> webSocket = mWebSocket;
+
+  // Call 'onerror' if needed
+  if (mFailed) {
+    nsresult rv = webSocket->CreateAndDispatchSimpleEvent(ERROR_EVENT_STRING);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to dispatch the error event");
+    }
+  }
+
+  nsresult rv = webSocket->CreateAndDispatchCloseEvent(
+      mCloseEventWasClean, mCloseEventCode, mCloseEventReason);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to dispatch the close event");
+  }
+
+  webSocket->UpdateMustKeepAlive();
+  Disconnect();
+}
+
+nsresult WebSocket::CreateAndDispatchSimpleEvent(const nsAString& aName) {
+  MOZ_ASSERT(mImpl);
+  AssertIsOnTargetThread();
+
+  nsresult rv = CheckCurrentGlobalCorrectness();
+  if (NS_FAILED(rv)) {
+    return NS_OK;
+  }
+
+  RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
+
+  // it doesn't bubble, and it isn't cancelable
+  event->InitEvent(aName, false, false);
+  event->SetTrusted(true);
+
+  ErrorResult err;
+  DispatchEvent(*event, err);
+  return err.StealNSResult();
+}
+
+nsresult WebSocket::CreateAndDispatchMessageEvent(const nsACString& aData,
+                                                  bool aIsBinary) {
+  MOZ_ASSERT(mImpl);
+  AssertIsOnTargetThread();
+
+  AutoJSAPI jsapi;
+  if (NS_WARN_IF(!jsapi.Init(GetOwnerGlobal()))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JSContext* cx = jsapi.cx();
+
+  nsresult rv = CheckCurrentGlobalCorrectness();
+  if (NS_FAILED(rv)) {
+    return NS_OK;
+  }
+
+  uint16_t messageType = nsIWebSocketEventListener::TYPE_STRING;
+
+  // Create appropriate JS object for message
+  JS::Rooted<JS::Value> jsData(cx);
+  if (aIsBinary) {
+    if (mBinaryType == dom::BinaryType::Blob) {
+      messageType = nsIWebSocketEventListener::TYPE_BLOB;
+
+      RefPtr<Blob> blob =
+          Blob::CreateStringBlob(GetOwnerGlobal(), aData, u""_ns);
+      if (NS_WARN_IF(!blob)) {
+        return NS_ERROR_FAILURE;
+      }
+
+      if (!ToJSValue(cx, blob, &jsData)) {
+        return NS_ERROR_FAILURE;
+      }
+
+    } else if (mBinaryType == dom::BinaryType::Arraybuffer) {
+      messageType = nsIWebSocketEventListener::TYPE_ARRAYBUFFER;
+
+      JS::Rooted<JSObject*> arrayBuf(cx);
+      nsresult rv =
+          nsContentUtils::CreateArrayBuffer(cx, aData, arrayBuf.address());
+      NS_ENSURE_SUCCESS(rv, rv);
+      jsData.setObject(*arrayBuf);
+    } else {
+      MOZ_CRASH("Unknown binary type!");
+      return NS_ERROR_UNEXPECTED;
+    }
+  } else {
+    // JS string
+    nsAutoString utf16Data;
+    if (!AppendUTF8toUTF16(aData, utf16Data, mozilla::fallible)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    JSString* jsString;
+    jsString = JS_NewUCStringCopyN(cx, utf16Data.get(), utf16Data.Length());
+    NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
+
+    jsData.setString(jsString);
+  }
+
+  mImpl->mService->WebSocketMessageAvailable(
+      mImpl->mChannel->Serial(), mImpl->mInnerWindowID, aData, messageType);
+
+  // create an event that uses the MessageEvent interface,
+  // which does not bubble, is not cancelable, and has no default action
+
+  RefPtr<MessageEvent> event = new MessageEvent(this, nullptr, nullptr);
+
+  event->InitMessageEvent(nullptr, MESSAGE_EVENT_STRING, CanBubble::eNo,
+                          Cancelable::eNo, jsData, mImpl->mUTF16Origin, u""_ns,
+                          nullptr, Sequence<OwningNonNull<MessagePort>>());
+  event->SetTrusted(true);
+
+  ErrorResult err;
+  DispatchEvent(*event, err);
+  return err.StealNSResult();
+}
+
+nsresult WebSocket::CreateAndDispatchCloseEvent(bool aWasClean, uint16_t aCode,
+                                                const nsAString& aReason) {
+  AssertIsOnTargetThread();
+
+  // This method is called by a runnable and it can happen that, in the
+  // meantime, GC unlinked this object, so mImpl could be null.
+  if (mImpl && mImpl->mChannel) {
+    mImpl->mService->WebSocketClosed(mImpl->mChannel->Serial(),
+                                     mImpl->mInnerWindowID, aWasClean, aCode,
+                                     aReason);
+  }
+
+  nsresult rv = CheckCurrentGlobalCorrectness();
+  if (NS_FAILED(rv)) {
+    return NS_OK;
+  }
+
+  CloseEventInit init;
+  init.mBubbles = false;
+  init.mCancelable = false;
+  init.mWasClean = aWasClean;
+  init.mCode = aCode;
+  init.mReason = aReason;
+
+  RefPtr<CloseEvent> event =
+      CloseEvent::Constructor(this, CLOSE_EVENT_STRING, init);
+  event->SetTrusted(true);
+
+  ErrorResult err;
+  DispatchEvent(*event, err);
+  return err.StealNSResult();
+}
+
+nsresult WebSocketImpl::ParseURL(const nsAString& aURL) {
+  AssertIsOnMainThread();
+  NS_ENSURE_TRUE(!aURL.IsEmpty(), NS_ERROR_DOM_SYNTAX_ERR);
+
+  if (mIsServerSide) {
+    mWebSocket->mURI = aURL;
+    CopyUTF16toUTF8(mWebSocket->mURI, mURI);
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_NewURI(getter_AddRefs(uri), aURL);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  nsCOMPtr<nsIURL> parsedURL = do_QueryInterface(uri, &rv);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  bool hasRef;
+  rv = parsedURL->GetHasRef(&hasRef);
+  NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && !hasRef, NS_ERROR_DOM_SYNTAX_ERR);
+
+  nsAutoCString scheme;
+  rv = parsedURL->GetScheme(scheme);
+  NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && !scheme.IsEmpty(),
+                 NS_ERROR_DOM_SYNTAX_ERR);
+
+  nsAutoCString host;
+  rv = parsedURL->GetAsciiHost(host);
+  NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && !host.IsEmpty(), NS_ERROR_DOM_SYNTAX_ERR);
+
+  int32_t port;
+  rv = parsedURL->GetPort(&port);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  nsAutoCString filePath;
+  rv = parsedURL->GetFilePath(filePath);
+  if (filePath.IsEmpty()) {
+    filePath.Assign('/');
+  }
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  nsAutoCString query;
+  rv = parsedURL->GetQuery(query);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  if (scheme.LowerCaseEqualsLiteral("ws")) {
+    mSecure = false;
+    mPort = (port == -1) ? DEFAULT_WS_SCHEME_PORT : port;
+  } else if (scheme.LowerCaseEqualsLiteral("wss")) {
+    mSecure = true;
+    mPort = (port == -1) ? DEFAULT_WSS_SCHEME_PORT : port;
+  } else {
+    return NS_ERROR_DOM_SYNTAX_ERR;
+  }
+
+  rv = nsContentUtils::GetUTFOrigin(parsedURL, mUTF16Origin);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR);
+
+  mAsciiHost = host;
+  ToLowerCase(mAsciiHost);
+
+  mResource = filePath;
+  if (!query.IsEmpty()) {
+    mResource.Append('?');
+    mResource.Append(query);
+  }
+  uint32_t length = mResource.Length();
+  uint32_t i;
+  for (i = 0; i < length; ++i) {
+    if (mResource[i] < static_cast<char16_t>(0x0021) ||
+        mResource[i] > static_cast<char16_t>(0x007E)) {
+      return NS_ERROR_DOM_SYNTAX_ERR;
+    }
+  }
+
+  rv = parsedURL->GetSpec(mURI);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+  CopyUTF8toUTF16(mURI, mWebSocket->mURI);
+  return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// Methods that keep alive the WebSocket object when:
+//   1. the object has registered event listeners that can be triggered
+//      ("strong event listeners");
+//   2. there are outgoing not sent messages.
+//-----------------------------------------------------------------------------
+
+void WebSocket::UpdateMustKeepAlive() {
+  // Here we could not have mImpl.
+  MOZ_ASSERT(NS_IsMainThread() == mIsMainThread);
+
+  if (!mCheckMustKeepAlive || !mImpl) {
+    return;
+  }
+
+  bool shouldKeepAlive = false;
+  uint16_t readyState = ReadyState();
+
+  if (mListenerManager) {
+    switch (readyState) {
+      case CONNECTING: {
+        if (mListenerManager->HasListenersFor(OPEN_EVENT_STRING) ||
+            mListenerManager->HasListenersFor(MESSAGE_EVENT_STRING) ||
+            mListenerManager->HasListenersFor(ERROR_EVENT_STRING) ||
+            mListenerManager->HasListenersFor(CLOSE_EVENT_STRING)) {
+          shouldKeepAlive = true;
+        }
+      } break;
+
+      case OPEN:
+      case CLOSING: {
+        if (mListenerManager->HasListenersFor(MESSAGE_EVENT_STRING) ||
+            mListenerManager->HasListenersFor(ERROR_EVENT_STRING) ||
+            mListenerManager->HasListenersFor(CLOSE_EVENT_STRING) ||
+            mOutgoingBufferedAmount.value() != 0) {
+          shouldKeepAlive = true;
+        }
+      } break;
+
+      case CLOSED: {
+        shouldKeepAlive = false;
+      }
+    }
+  }
+
+  if (mKeepingAlive && !shouldKeepAlive) {
+    mKeepingAlive = false;
+    mImpl->ReleaseObject();
+  } else if (!mKeepingAlive && shouldKeepAlive) {
+    mKeepingAlive = true;
+    mImpl->AddRefObject();
+  }
+}
+
+void WebSocket::DontKeepAliveAnyMore() {
+  // Here we could not have mImpl.
+  MOZ_ASSERT(NS_IsMainThread() == mIsMainThread);
+
+  if (mKeepingAlive) {
+    MOZ_ASSERT(mImpl);
+
+    mKeepingAlive = false;
+    mImpl->ReleaseObject();
+  }
+
+  mCheckMustKeepAlive = false;
+}
+
+void WebSocketImpl::AddRefObject() {
+  AssertIsOnTargetThread();
+  AddRef();
+}
+
+void WebSocketImpl::ReleaseObject() {
+  AssertIsOnTargetThread();
+  Release();
+}
+
+bool WebSocketImpl::RegisterWorkerRef(WorkerPrivate* aWorkerPrivate) {
+  MOZ_ASSERT(aWorkerPrivate);
+
+  RefPtr<WebSocketImpl> self = this;
+
+  // In workers we have to keep the worker alive using a strong reference in
+  // order to dispatch messages correctly.
+  RefPtr<StrongWorkerRef> workerRef =
+      StrongWorkerRef::Create(aWorkerPrivate, "WebSocketImpl", [self]() {
+        {
+          MutexAutoLock lock(self->mMutex);
+          self->mWorkerShuttingDown = true;
+        }
+
+        self->CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY, ""_ns);
+      });
+  if (NS_WARN_IF(!workerRef)) {
+    return false;
+  }
+
+  mWorkerRef = new ThreadSafeWorkerRef(workerRef);
+  MOZ_ASSERT(mWorkerRef);
+
+  return true;
+}
+
+void WebSocketImpl::UnregisterWorkerRef() {
+  MOZ_ASSERT(mDisconnectingOrDisconnected);
+  MOZ_ASSERT(mWorkerRef);
+  mWorkerRef->Private()->AssertIsOnWorkerThread();
+
+  {
+    MutexAutoLock lock(mMutex);
+    mWorkerShuttingDown = true;
+  }
+
+  // The DTOR of this StrongWorkerRef will release the worker for us.
+  mWorkerRef = nullptr;
+}
+
+nsresult WebSocketImpl::UpdateURI() {
+  AssertIsOnTargetThread();
+
+  // Check for Redirections
+  RefPtr<BaseWebSocketChannel> channel;
+  channel = static_cast<BaseWebSocketChannel*>(mChannel.get());
+  MOZ_ASSERT(channel);
+
+  channel->GetEffectiveURL(mWebSocket->mEffectiveURL);
+  mSecure = channel->IsEncrypted();
+
+  return NS_OK;
+}
+
+void WebSocket::EventListenerAdded(nsAtom* aType) {
+  AssertIsOnTargetThread();
+  UpdateMustKeepAlive();
+}
+
+void WebSocket::EventListenerRemoved(nsAtom* aType) {
+  AssertIsOnTargetThread();
+  UpdateMustKeepAlive();
+}
+
+//-----------------------------------------------------------------------------
+// WebSocket - methods
+//-----------------------------------------------------------------------------
+
+// webIDL: readonly attribute unsigned short readyState;
+uint16_t WebSocket::ReadyState() {
+  MutexAutoLock lock(mMutex);
+  return mReadyState;
+}
+
+void WebSocket::SetReadyState(uint16_t aReadyState) {
+  MutexAutoLock lock(mMutex);
+  mReadyState = aReadyState;
+}
+
+// webIDL: readonly attribute unsigned long long bufferedAmount;
+uint64_t WebSocket::BufferedAmount() const {
+  AssertIsOnTargetThread();
+  MOZ_RELEASE_ASSERT(mOutgoingBufferedAmount.isValid());
+  return mOutgoingBufferedAmount.value();
+}
+
+// webIDL: attribute BinaryType binaryType;
+dom::BinaryType WebSocket::BinaryType() const {
+  AssertIsOnTargetThread();
+  return mBinaryType;
+}
+
+// webIDL: attribute BinaryType binaryType;
+void WebSocket::SetBinaryType(dom::BinaryType aData) {
+  AssertIsOnTargetThread();
+  mBinaryType = aData;
+}
+
+// webIDL: readonly attribute DOMString url
+void WebSocket::GetUrl(nsAString& aURL) {
+  AssertIsOnTargetThread();
+
+  if (mEffectiveURL.IsEmpty()) {
+    aURL = mURI;
+  } else {
+    aURL = mEffectiveURL;
+  }
+}
+
+// webIDL: readonly attribute DOMString extensions;
+void WebSocket::GetExtensions(nsAString& aExtensions) {
+  AssertIsOnTargetThread();
+  CopyUTF8toUTF16(mEstablishedExtensions, aExtensions);
+}
+
+// webIDL: readonly attribute DOMString protocol;
+void WebSocket::GetProtocol(nsAString& aProtocol) {
+  AssertIsOnTargetThread();
+  CopyUTF8toUTF16(mEstablishedProtocol, aProtocol);
+}
+
+// webIDL: void send(DOMString data);
+void WebSocket::Send(const nsAString& aData, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  nsAutoCString msgString;
+  if (!AppendUTF16toUTF8(aData, msgString, mozilla::fallible_t())) {
+    aRv.Throw(NS_ERROR_FILE_TOO_BIG);
+    return;
+  }
+  Send(nullptr, msgString, msgString.Length(), false, aRv);
+}
+
+void WebSocket::Send(Blob& aData, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  nsCOMPtr<nsIInputStream> msgStream;
+  aData.CreateInputStream(getter_AddRefs(msgStream), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  uint64_t msgLength = aData.GetSize(aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  if (msgLength > UINT32_MAX) {
+    aRv.Throw(NS_ERROR_FILE_TOO_BIG);
+    return;
+  }
+
+  Send(msgStream, ""_ns, msgLength, true, aRv);
+}
+
+void WebSocket::Send(const ArrayBuffer& aData, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  aData.ComputeState();
+
+  static_assert(sizeof(*aData.Data()) == 1, "byte-sized data required");
+
+  uint32_t len = aData.Length();
+  char* data = reinterpret_cast<char*>(aData.Data());
+
+  nsDependentCSubstring msgString;
+  if (!msgString.Assign(data, len, mozilla::fallible_t())) {
+    aRv.Throw(NS_ERROR_FILE_TOO_BIG);
+    return;
+  }
+  Send(nullptr, msgString, len, true, aRv);
+}
+
+void WebSocket::Send(const ArrayBufferView& aData, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  aData.ComputeState();
+
+  static_assert(sizeof(*aData.Data()) == 1, "byte-sized data required");
+
+  uint32_t len = aData.Length();
+  char* data = reinterpret_cast<char*>(aData.Data());
+
+  nsDependentCSubstring msgString;
+  if (!msgString.Assign(data, len, mozilla::fallible_t())) {
+    aRv.Throw(NS_ERROR_FILE_TOO_BIG);
+    return;
+  }
+  Send(nullptr, msgString, len, true, aRv);
+}
+
+void WebSocket::Send(nsIInputStream* aMsgStream, const nsACString& aMsgString,
+                     uint32_t aMsgLength, bool aIsBinary, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  int64_t readyState = ReadyState();
+  if (readyState == CONNECTING) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  CheckedUint64 outgoingBufferedAmount = mOutgoingBufferedAmount;
+  outgoingBufferedAmount += aMsgLength;
+  if (!outgoingBufferedAmount.isValid()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  // Always increment outgoing buffer len, even if closed
+  mOutgoingBufferedAmount = outgoingBufferedAmount;
+  MOZ_RELEASE_ASSERT(mOutgoingBufferedAmount.isValid());
+
+  if (readyState == CLOSING || readyState == CLOSED) {
+    return;
+  }
+
+  // We must have mImpl when connected.
+  MOZ_ASSERT(mImpl);
+  MOZ_ASSERT(readyState == OPEN, "Unknown state in WebSocket::Send");
+
+  nsresult rv;
+  if (aMsgStream) {
+    rv = mImpl->mChannel->SendBinaryStream(aMsgStream, aMsgLength);
+  } else {
+    if (aIsBinary) {
+      rv = mImpl->mChannel->SendBinaryMsg(aMsgString);
+    } else {
+      rv = mImpl->mChannel->SendMsg(aMsgString);
+    }
+  }
+
+  if (NS_FAILED(rv)) {
+    aRv.Throw(rv);
+    return;
+  }
+
+  UpdateMustKeepAlive();
+}
+
+// webIDL: void close(optional unsigned short code, optional DOMString reason):
+void WebSocket::Close(const Optional<uint16_t>& aCode,
+                      const Optional<nsAString>& aReason, ErrorResult& aRv) {
+  AssertIsOnTargetThread();
+
+  // the reason code is optional, but if provided it must be in a specific range
+  uint16_t closeCode = 0;
+  if (aCode.WasPassed()) {
+    if (aCode.Value() != 1000 &&
+        (aCode.Value() < 3000 || aCode.Value() > 4999)) {
+      aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+      return;
+    }
+    closeCode = aCode.Value();
+  }
+
+  nsCString closeReason;
+  if (aReason.WasPassed()) {
+    CopyUTF16toUTF8(aReason.Value(), closeReason);
+
+    // The API requires the UTF-8 string to be 123 or less bytes
+    if (closeReason.Length() > 123) {
+      aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+      return;
+    }
+  }
+
+  int64_t readyState = ReadyState();
+  if (readyState == CLOSING || readyState == CLOSED) {
+    return;
+  }
+
+  // If we don't have mImpl, we are in a shutting down worker where we are still
+  // in CONNECTING state, but already disconnected internally.
+  if (!mImpl) {
+    MOZ_ASSERT(readyState == CONNECTING);
+    SetReadyState(CLOSING);
+    return;
+  }
+
+  RefPtr<WebSocketImpl> impl = mImpl;
+  if (readyState == CONNECTING) {
+    impl->FailConnection(closeCode, closeReason);
+    return;
+  }
+
+  MOZ_ASSERT(readyState == OPEN);
+  impl->CloseConnection(closeCode, closeReason);
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl::nsIObserver
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+WebSocketImpl::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData) {
+  AssertIsOnMainThread();
+
+  int64_t readyState = mWebSocket->ReadyState();
+  if ((readyState == WebSocket::CLOSING) || (readyState == WebSocket::CLOSED)) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aSubject);
+  if (!mWebSocket->GetOwner() || window != mWebSocket->GetOwner()) {
+    return NS_OK;
+  }
+
+  if ((strcmp(aTopic, DOM_WINDOW_FROZEN_TOPIC) == 0) ||
+      (strcmp(aTopic, DOM_WINDOW_DESTROYED_TOPIC) == 0)) {
+    CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
+  }
+
+  return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// WebSocketImpl::nsIRequest
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+WebSocketImpl::GetName(nsACString& aName) {
+  AssertIsOnMainThread();
+
+  CopyUTF16toUTF8(mWebSocket->mURI, aName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::IsPending(bool* aValue) {
+  AssertIsOnTargetThread();
+
+  int64_t readyState = mWebSocket->ReadyState();
+  *aValue = (readyState != WebSocket::CLOSED);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::GetStatus(nsresult* aStatus) {
+  AssertIsOnTargetThread();
+
+  *aStatus = NS_OK;
+  return NS_OK;
+}
+
+namespace {
+
+class CancelRunnable final : public MainThreadWorkerRunnable {
+ public:
+  CancelRunnable(ThreadSafeWorkerRef* aWorkerRef, WebSocketImpl* aImpl)
+      : MainThreadWorkerRunnable(aWorkerRef->Private()), mImpl(aImpl) {}
+
+  bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
+    aWorkerPrivate->AssertIsOnWorkerThread();
+    return !NS_FAILED(mImpl->CancelInternal());
+  }
+
+ private:
+  RefPtr<WebSocketImpl> mImpl;
+};
+
+}  // namespace
+
+NS_IMETHODIMP WebSocketImpl::SetCanceledReason(const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP WebSocketImpl::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP WebSocketImpl::CancelWithReason(nsresult aStatus,
+                                              const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
+// Window closed, stop/reload button pressed, user navigated away from page,
+// etc.
+NS_IMETHODIMP
+WebSocketImpl::Cancel(nsresult aStatus) {
+  AssertIsOnMainThread();
+
+  if (!mIsMainThread) {
+    MOZ_ASSERT(mWorkerRef);
+    RefPtr<CancelRunnable> runnable = new CancelRunnable(mWorkerRef, this);
+    if (!runnable->Dispatch()) {
+      return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+  }
+
+  return CancelInternal();
+}
+
+nsresult WebSocketImpl::CancelInternal() {
+  AssertIsOnTargetThread();
+
+  // If CancelInternal is called by a runnable, we may already be disconnected
+  // by the time it runs.
+  if (mDisconnectingOrDisconnected) {
+    return NS_OK;
+  }
+
+  int64_t readyState = mWebSocket->ReadyState();
+  if (readyState == WebSocket::CLOSING || readyState == WebSocket::CLOSED) {
+    return NS_OK;
+  }
+
+  return CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
+}
+
+NS_IMETHODIMP
+WebSocketImpl::Suspend() {
+  AssertIsOnMainThread();
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::Resume() {
+  AssertIsOnMainThread();
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::GetLoadGroup(nsILoadGroup** aLoadGroup) {
+  AssertIsOnMainThread();
+
+  *aLoadGroup = nullptr;
+
+  if (mIsMainThread) {
+    nsCOMPtr<Document> doc = mWebSocket->GetDocumentIfCurrent();
+    if (doc) {
+      *aLoadGroup = doc->GetDocumentLoadGroup().take();
+    }
+
+    return NS_OK;
+  }
+
+  MOZ_ASSERT(mWorkerRef);
+
+  // Walk up to our containing page
+  WorkerPrivate* wp = mWorkerRef->Private();
+  while (wp->GetParent()) {
+    wp = wp->GetParent();
+  }
+
+  nsPIDOMWindowInner* window = wp->GetWindow();
+  if (!window) {
+    return NS_OK;
+  }
+
+  Document* doc = window->GetExtantDoc();
+  if (doc) {
+    *aLoadGroup = doc->GetDocumentLoadGroup().take();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::SetLoadGroup(nsILoadGroup* aLoadGroup) {
+  AssertIsOnMainThread();
+  return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::GetLoadFlags(nsLoadFlags* aLoadFlags) {
+  AssertIsOnMainThread();
+
+  *aLoadFlags = nsIRequest::LOAD_BACKGROUND;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::SetLoadFlags(nsLoadFlags aLoadFlags) {
+  AssertIsOnMainThread();
+
+  // we won't change the load flags at all.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
+  return GetTRRModeImpl(aTRRMode);
+}
+
+NS_IMETHODIMP
+WebSocketImpl::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
+  return SetTRRModeImpl(aTRRMode);
+}
+
+namespace {
+
+class WorkerRunnableDispatcher final : public WorkerRunnable {
+  RefPtr<WebSocketImpl> mWebSocketImpl;
+
+ public:
+  WorkerRunnableDispatcher(WebSocketImpl* aImpl,
+                           ThreadSafeWorkerRef* aWorkerRef,
+                           already_AddRefed<nsIRunnable> aEvent)
+      : WorkerRunnable(aWorkerRef->Private(), WorkerThreadUnchangedBusyCount),
+        mWebSocketImpl(aImpl),
+        mEvent(std::move(aEvent)) {}
+
+  bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
+    aWorkerPrivate->AssertIsOnWorkerThread();
+
+    // No messages when disconnected.
+    if (mWebSocketImpl->mDisconnectingOrDisconnected) {
+      NS_WARNING("Dispatching a WebSocket event after the disconnection!");
+      return true;
+    }
+
+    return !NS_FAILED(mEvent->Run());
+  }
+
+  void PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
+               bool aRunResult) override {}
+
+  bool PreDispatch(WorkerPrivate* aWorkerPrivate) override {
+    // We don't call WorkerRunnable::PreDispatch because it would assert the
+    // wrong thing about which thread we're on.  We're on whichever thread the
+    // channel implementation is running on (probably the main thread or socket
+    // transport thread).
+    return true;
+  }
+
+  void PostDispatch(WorkerPrivate* aWorkerPrivate,
+                    bool aDispatchResult) override {
+    // We don't call WorkerRunnable::PreDispatch because it would assert the
+    // wrong thing about which thread we're on.  We're on whichever thread the
+    // channel implementation is running on (probably the main thread or socket
+    // transport thread).
+  }
+
+ private:
+  nsCOMPtr<nsIRunnable> mEvent;
+};
+
+}  // namespace
+
+NS_IMETHODIMP
+WebSocketImpl::DispatchFromScript(nsIRunnable* aEvent, uint32_t aFlags) {
+  nsCOMPtr<nsIRunnable> event(aEvent);
+  return Dispatch(event.forget(), aFlags);
+}
+
+NS_IMETHODIMP
+WebSocketImpl::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags) {
+  nsCOMPtr<nsIRunnable> event_ref(aEvent);
+  // If the target is the main-thread, we should try to dispatch the runnable
+  // to a labeled event target.
+  if (mIsMainThread) {
+    return mMainThreadEventTarget
+               ? mMainThreadEventTarget->Dispatch(event_ref.forget())
+               : GetMainThreadSerialEventTarget()->Dispatch(event_ref.forget());
+  }
+
+  MutexAutoLock lock(mMutex);
+  if (mWorkerShuttingDown) {
+    return NS_OK;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(mWorkerRef);
+
+  // If the target is a worker, we have to use a custom WorkerRunnableDispatcher
+  // runnable.
+  RefPtr<WorkerRunnableDispatcher> event =
+      new WorkerRunnableDispatcher(this, mWorkerRef, event_ref.forget());
+
+  if (!event->Dispatch()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::RegisterShutdownTask(nsITargetShutdownTask*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::UnregisterShutdownTask(nsITargetShutdownTask*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+WebSocketImpl::IsOnCurrentThread(bool* aResult) {
+  *aResult = IsTargetThread();
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(bool)
+WebSocketImpl::IsOnCurrentThreadInfallible() { return IsTargetThread(); }
+
+bool WebSocketImpl::IsTargetThread() const {
+  // FIXME: This should also check if we're on the worker thread. Code using
+  // `IsOnCurrentThread` could easily misbehave here!
+  return NS_IsMainThread() == mIsMainThread;
+}
+
+void WebSocket::AssertIsOnTargetThread() const {
+  MOZ_ASSERT(NS_IsMainThread() == mIsMainThread);
+}
+
+nsresult WebSocketImpl::IsSecure(bool* aValue) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mIsMainThread);
+
+  // Check the principal's uri to determine if we were loaded from https.
+  nsCOMPtr<nsIGlobalObject> globalObject(GetEntryGlobal());
+  nsCOMPtr<nsIPrincipal> principal;
+
+  if (globalObject) {
+    principal = globalObject->PrincipalOrNull();
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> innerWindow = do_QueryInterface(globalObject);
+  if (!innerWindow) {
+    // If we are in a XPConnect sandbox or in a JS component,
+    // innerWindow will be null. There is nothing on top of this to be
+    // considered.
+    if (NS_WARN_IF(!principal)) {
+      return NS_OK;
+    }
+    *aValue = principal->SchemeIs("https");
+    return NS_OK;
+  }
+
+  RefPtr<WindowContext> windowContext = innerWindow->GetWindowContext();
+  if (NS_WARN_IF(!windowContext)) {
+    return NS_ERROR_DOM_SECURITY_ERR;
+  }
+
+  while (true) {
+    if (windowContext->GetIsSecure()) {
+      *aValue = true;
+      return NS_OK;
+    }
+
+    if (windowContext->IsTop()) {
+      break;
+    } else {
+      // If we're not a top window get the parent window context instead.
+      windowContext = windowContext->GetParentWindowContext();
+    }
+
+    if (NS_WARN_IF(!windowContext)) {
+      return NS_ERROR_DOM_SECURITY_ERR;
+    }
+  }
+
+  *aValue = windowContext->GetIsSecure();
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/websocket/WebSocket.h b/dom/websocket/WebSocket.h
new file mode 100644
index 0000000000..a290750cf0
--- /dev/null
+++ b/dom/websocket/WebSocket.h
@@ -0,0 +1,192 @@
+/* -*- 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/. */
+
+#ifndef WebSocket_h__
+#define WebSocket_h__
+
+#include "mozilla/Attributes.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/dom/WebSocketBinding.h"  // for BinaryType
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/Mutex.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsISupports.h"
+#include "nsISupportsUtils.h"
+#include "nsString.h"
+#include "nsWrapperCache.h"
+
+#define DEFAULT_WS_SCHEME_PORT 80
+#define DEFAULT_WSS_SCHEME_PORT 443
+
+class nsIInputStream;
+class nsITransportProvider;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class Blob;
+class StringOrStringSequence;
+class WebSocketImpl;
+
+class WebSocket final : public DOMEventTargetHelper {
+  friend class WebSocketImpl;
+
+ public:
+  enum { CONNECTING = 0, OPEN = 1, CLOSING = 2, CLOSED = 3 };
+
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WebSocket, DOMEventTargetHelper)
+  virtual bool IsCertainlyAliveForCC() const override;
+
+  // EventTarget
+  using EventTarget::EventListenerAdded;
+  virtual void EventListenerAdded(nsAtom* aType) override;
+
+  using EventTarget::EventListenerRemoved;
+  virtual void EventListenerRemoved(nsAtom* aType) override;
+
+  virtual void DisconnectFromOwner() override;
+
+  mozilla::Maybe<EventCallbackDebuggerNotificationType>
+  GetDebuggerNotificationType() const override;
+
+  // nsWrapperCache
+  virtual JSObject* WrapObject(JSContext* cx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+ public:  // static helpers:
+  // Determine if preferences allow WebSocket
+  static bool PrefEnabled(JSContext* aCx = nullptr,
+                          JSObject* aGlobal = nullptr);
+
+ public:  // WebIDL interface:
+  // Constructor:
+  static already_AddRefed<WebSocket> Constructor(
+      const GlobalObject& aGlobal, const nsAString& aUrl,
+      const StringOrStringSequence& aProtocols, ErrorResult& rv);
+
+  static already_AddRefed<WebSocket> CreateServerWebSocket(
+      const GlobalObject& aGlobal, const nsAString& aUrl,
+      const Sequence<nsString>& aProtocols,
+      nsITransportProvider* aTransportProvider,
+      const nsAString& aNegotiatedExtensions, ErrorResult& rv);
+
+  static already_AddRefed<WebSocket> ConstructorCommon(
+      const GlobalObject& aGlobal, const nsAString& aUrl,
+      const Sequence<nsString>& aProtocols,
+      nsITransportProvider* aTransportProvider,
+      const nsACString& aNegotiatedExtensions, ErrorResult& rv);
+
+  // webIDL: readonly attribute DOMString url
+  void GetUrl(nsAString& aResult);
+
+  // webIDL: readonly attribute unsigned short readyState;
+  uint16_t ReadyState();
+
+  // webIDL: readonly attribute unsigned long long bufferedAmount;
+  uint64_t BufferedAmount() const;
+
+  // webIDL: attribute Function? onopen;
+  IMPL_EVENT_HANDLER(open)
+
+  // webIDL: attribute Function? onerror;
+  IMPL_EVENT_HANDLER(error)
+
+  // webIDL: attribute Function? onclose;
+  IMPL_EVENT_HANDLER(close)
+
+  // webIDL: readonly attribute DOMString extensions;
+  void GetExtensions(nsAString& aResult);
+
+  // webIDL: readonly attribute DOMString protocol;
+  void GetProtocol(nsAString& aResult);
+
+  // webIDL: void close(optional unsigned short code,
+  //                    optional DOMString reason):
+  void Close(const Optional<uint16_t>& aCode,
+             const Optional<nsAString>& aReason, ErrorResult& aRv);
+
+  // webIDL: attribute Function? onmessage;
+  IMPL_EVENT_HANDLER(message)
+
+  // webIDL: attribute DOMString binaryType;
+  dom::BinaryType BinaryType() const;
+  void SetBinaryType(dom::BinaryType aData);
+
+  // webIDL: void send(DOMString|Blob|ArrayBufferView data);
+  void Send(const nsAString& aData, ErrorResult& aRv);
+  void Send(Blob& aData, ErrorResult& aRv);
+  void Send(const ArrayBuffer& aData, ErrorResult& aRv);
+  void Send(const ArrayBufferView& aData, ErrorResult& aRv);
+
+ private:  // constructor && destructor
+  explicit WebSocket(nsIGlobalObject* aGlobal);
+  virtual ~WebSocket();
+
+  void SetReadyState(uint16_t aReadyState);
+
+  // These methods actually do the dispatch for various events.
+  nsresult CreateAndDispatchSimpleEvent(const nsAString& aName);
+  nsresult CreateAndDispatchMessageEvent(const nsACString& aData,
+                                         bool aIsBinary);
+  nsresult CreateAndDispatchCloseEvent(bool aWasClean, uint16_t aCode,
+                                       const nsAString& aReason);
+
+  static bool IsValidProtocolString(const nsString& aValue);
+
+  // if there are "strong event listeners" (see comment in WebSocket.cpp) or
+  // outgoing not sent messages then this method keeps the object alive
+  // when js doesn't have strong references to it.
+  void UpdateMustKeepAlive();
+  // ATTENTION, when calling this method the object can be released
+  // (and possibly collected).
+  void DontKeepAliveAnyMore();
+
+ private:
+  WebSocket(const WebSocket& x) = delete;  // prevent bad usage
+  WebSocket& operator=(const WebSocket& x) = delete;
+
+  void Send(nsIInputStream* aMsgStream, const nsACString& aMsgString,
+            uint32_t aMsgLength, bool aIsBinary, ErrorResult& aRv);
+
+  void AssertIsOnTargetThread() const;
+
+  // Raw pointer because this WebSocketImpl is created, managed and destroyed by
+  // WebSocket.
+  WebSocketImpl* mImpl;
+
+  bool mIsMainThread;
+
+  bool mKeepingAlive;
+  bool mCheckMustKeepAlive;
+
+  CheckedUint64 mOutgoingBufferedAmount;
+
+  // related to the WebSocket constructor steps
+  nsString mURI;
+  nsString mEffectiveURL;  // after redirects
+  nsCString mEstablishedExtensions;
+  nsCString mEstablishedProtocol;
+
+  dom::BinaryType mBinaryType;
+
+  // This mutex protects mReadyState that is the only variable that is used in
+  // different threads.
+  mozilla::Mutex mMutex;
+
+  // This value should not be used directly but use ReadyState() instead.
+  uint16_t mReadyState MOZ_GUARDED_BY(mMutex);
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif
diff --git a/dom/websocket/moz.build b/dom/websocket/moz.build
new file mode 100644
index 0000000000..fbd2399e42
--- /dev/null
+++ b/dom/websocket/moz.build
@@ -0,0 +1,33 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "DOM: Networking")
+
+EXPORTS.mozilla.dom += [
+    "WebSocket.h",
+]
+
+UNIFIED_SOURCES += [
+    "WebSocket.cpp",
+]
+
+LOCAL_INCLUDES += [
+    "/dom/base",
+]
+
+MOCHITEST_CHROME_MANIFESTS += [
+    "tests/chrome.ini",
+]
+
+MOCHITEST_MANIFESTS += [
+    "tests/mochitest.ini",
+    "tests/websocket_hybi/mochitest.ini",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/websocket/tests/chrome.ini b/dom/websocket/tests/chrome.ini
new file mode 100644
index 0000000000..b781f62e6e
--- /dev/null
+++ b/dom/websocket/tests/chrome.ini
@@ -0,0 +1,4 @@
+[DEFAULT]
+skip-if = os == 'android'
+
+[test_websocket_frame.html]
diff --git a/dom/websocket/tests/file_bug1384658.html b/dom/websocket/tests/file_bug1384658.html
new file mode 100644
index 0000000000..9db632831e
--- /dev/null
+++ b/dom/websocket/tests/file_bug1384658.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<script>
+  onload = function() {
+    function done(success) {
+      var bc = new BroadcastChannel("test_channel");
+      bc.postMessage({success});
+      bc.close();
+    }
+    try {
+      new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic");
+      done(true); // no hang!
+    } catch (e) {
+      done(false);
+    }
+  }
+</script>
+</html>
diff --git a/dom/websocket/tests/file_websocket_basic_wsh.py b/dom/websocket/tests/file_websocket_basic_wsh.py
new file mode 100644
index 0000000000..050e7ccc10
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_basic_wsh.py
@@ -0,0 +1,31 @@
+from mod_pywebsocket import msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    # must set request.ws_protocol to the selected version from ws_requested_protocols
+    request.ws_protocol = request.ws_requested_protocols[0]
+
+    if request.ws_protocol == "error":
+        raise ValueError("Error")
+    pass
+
+
+def web_socket_transfer_data(request):
+    while True:
+        line = msgutil.receive_message(request)
+        if line == "protocol":
+            msgutil.send_message(request, request.ws_protocol)
+            continue
+
+        if line == "resource":
+            msgutil.send_message(request, request.ws_resource)
+            continue
+
+        if line == "origin":
+            msgutil.send_message(request, request.ws_origin)
+            continue
+
+        msgutil.send_message(request, line)
+
+        if line == "end":
+            return
diff --git a/dom/websocket/tests/file_websocket_bigBlob_wsh.py b/dom/websocket/tests/file_websocket_bigBlob_wsh.py
new file mode 100644
index 0000000000..5ccc85f3a0
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_bigBlob_wsh.py
@@ -0,0 +1,11 @@
+from mod_pywebsocket import msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    pass
+
+
+def web_socket_transfer_data(request):
+    while True:
+        line = msgutil.receive_message(request)
+        msgutil.send_message(request, line, True, True)
diff --git a/dom/websocket/tests/file_websocket_hello_wsh.py b/dom/websocket/tests/file_websocket_hello_wsh.py
new file mode 100644
index 0000000000..5711d2283c
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_hello_wsh.py
@@ -0,0 +1,12 @@
+from mod_pywebsocket import msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    pass
+
+
+def web_socket_transfer_data(request):
+    resp = "Test"
+    if msgutil.receive_message(request) == "data":
+        resp = "Hello world!"
+    msgutil.send_message(request, resp)
diff --git a/dom/websocket/tests/file_websocket_http_resource.txt b/dom/websocket/tests/file_websocket_http_resource.txt
new file mode 100644
index 0000000000..35dc67f08d
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_http_resource.txt
@@ -0,0 +1 @@
+server data
diff --git a/dom/websocket/tests/file_websocket_permessage_deflate_disabled_wsh.py b/dom/websocket/tests/file_websocket_permessage_deflate_disabled_wsh.py
new file mode 100644
index 0000000000..5853f8acd7
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_permessage_deflate_disabled_wsh.py
@@ -0,0 +1,18 @@
+from mod_pywebsocket import common, msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    if request.ws_requested_extensions is not None:
+        for extension_request in request.ws_requested_extensions:
+            if extension_request.name() == "permessage-deflate":
+                raise ValueError("permessage-deflate should not be offered")
+
+
+def web_socket_transfer_data(request):
+    while True:
+        rcvd = msgutil.receive_message(request)
+        opcode = request.ws_stream.get_last_received_opcode()
+        if opcode == common.OPCODE_BINARY:
+            msgutil.send_message(request, rcvd, binary=True)
+        elif opcode == common.OPCODE_TEXT:
+            msgutil.send_message(request, rcvd)
diff --git a/dom/websocket/tests/file_websocket_permessage_deflate_params_wsh.py b/dom/websocket/tests/file_websocket_permessage_deflate_params_wsh.py
new file mode 100644
index 0000000000..e6ea12232f
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_permessage_deflate_params_wsh.py
@@ -0,0 +1,24 @@
+from mod_pywebsocket import common, msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    deflate_found = False
+
+    if request.ws_extension_processors is not None:
+        for extension_processor in request.ws_extension_processors:
+            if extension_processor.name() == "deflate":
+                extension_processor.set_client_no_context_takeover(True)
+                deflate_found = True
+
+    if deflate_found is False:
+        raise ValueError("deflate extension processor not found")
+
+
+def web_socket_transfer_data(request):
+    while True:
+        rcvd = msgutil.receive_message(request)
+        opcode = request.ws_stream.get_last_received_opcode()
+        if opcode == common.OPCODE_BINARY:
+            msgutil.send_message(request, rcvd, binary=True)
+        elif opcode == common.OPCODE_TEXT:
+            msgutil.send_message(request, rcvd)
diff --git a/dom/websocket/tests/file_websocket_permessage_deflate_rejected_wsh.py b/dom/websocket/tests/file_websocket_permessage_deflate_rejected_wsh.py
new file mode 100644
index 0000000000..b67627d67c
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_permessage_deflate_rejected_wsh.py
@@ -0,0 +1,24 @@
+from mod_pywebsocket import common, msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    deflate_removed = False
+
+    if request.ws_extension_processors is not None:
+        for extension_processor in request.ws_extension_processors:
+            if extension_processor.name() == "deflate":
+                request.ws_extension_processors.remove(extension_processor)
+                deflate_removed = True
+
+    if deflate_removed is False:
+        raise ValueError("deflate extension processor not found")
+
+
+def web_socket_transfer_data(request):
+    while True:
+        rcvd = msgutil.receive_message(request)
+        opcode = request.ws_stream.get_last_received_opcode()
+        if opcode == common.OPCODE_BINARY:
+            msgutil.send_message(request, rcvd, binary=True)
+        elif opcode == common.OPCODE_TEXT:
+            msgutil.send_message(request, rcvd)
diff --git a/dom/websocket/tests/file_websocket_permessage_deflate_wsh.py b/dom/websocket/tests/file_websocket_permessage_deflate_wsh.py
new file mode 100644
index 0000000000..c6436c8499
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_permessage_deflate_wsh.py
@@ -0,0 +1,23 @@
+from mod_pywebsocket import common, msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    pmce_offered = False
+
+    if request.ws_requested_extensions is not None:
+        for extension_request in request.ws_requested_extensions:
+            if extension_request.name() == "permessage-deflate":
+                pmce_offered = True
+
+    if pmce_offered is False:
+        raise ValueError("permessage-deflate not offered")
+
+
+def web_socket_transfer_data(request):
+    while True:
+        rcvd = msgutil.receive_message(request)
+        opcode = request.ws_stream.get_last_received_opcode()
+        if opcode == common.OPCODE_BINARY:
+            msgutil.send_message(request, rcvd, binary=True)
+        elif opcode == common.OPCODE_TEXT:
+            msgutil.send_message(request, rcvd)
diff --git a/dom/websocket/tests/file_websocket_wsh.py b/dom/websocket/tests/file_websocket_wsh.py
new file mode 100644
index 0000000000..de69f747e8
--- /dev/null
+++ b/dom/websocket/tests/file_websocket_wsh.py
@@ -0,0 +1,168 @@
+import time
+
+import six
+from mod_pywebsocket import msgutil
+
+# see the list of tests in test_websocket.html
+
+
+def web_socket_do_extra_handshake(request):
+    # must set request.ws_protocol to the selected version from ws_requested_protocols
+    for x in request.ws_requested_protocols:
+        if x != "test-does-not-exist":
+            request.ws_protocol = x
+            break
+
+    if request.ws_protocol == "test-2.1":
+        time.sleep(3)
+    elif request.ws_protocol == "test-9":
+        time.sleep(3)
+    elif request.ws_protocol == "test-10":
+        time.sleep(3)
+    elif request.ws_protocol == "test-19":
+        raise ValueError("Aborting (test-19)")
+    elif request.ws_protocol == "test-20" or request.ws_protocol == "test-17":
+        time.sleep(3)
+    elif request.ws_protocol == "test-22":
+        # The timeout is 5 seconds
+        time.sleep(13)
+    elif request.ws_protocol == "test-41b":
+        request.sts = "max-age=100"
+    elif request.ws_protocol == "test-49":
+        # subprotocols are compared case-sensitively, so this should fail
+        request.ws_protocol = "teST-49"
+    else:
+        pass
+
+
+# Behave according to recommendation of RFC 6455, section # 5.5.1:
+#  "When sending a Close frame in response, the endpoint typically echos the
+#   status code it received."
+# - Without this, pywebsocket replies with 1000 to any close code.
+#
+#  Note that this function is only called when the client initiates the close
+
+
+def web_socket_passive_closing_handshake(request):
+    if request.ws_close_code == 1005:
+        return None, None
+    return request.ws_close_code, request.ws_close_reason
+
+
+def web_socket_transfer_data(request):
+    if request.ws_protocol == "test-2.1" or request.ws_protocol == "test-2.2":
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-6":
+        resp = "wrong message"
+        if msgutil.receive_message(request) == "1":
+            resp = "2"
+        msgutil.send_message(request, six.ensure_text(resp))
+        resp = "wrong message"
+        if msgutil.receive_message(request) == "3":
+            resp = "4"
+        msgutil.send_message(request, six.ensure_text(resp))
+        resp = "wrong message"
+        if msgutil.receive_message(request) == "5":
+            resp = (
+                b"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a".decode(
+                    "utf-8"
+                )
+            )
+        msgutil.send_message(request, six.ensure_text(resp))
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-7":
+        msgutil.send_message(request, "test-7 data")
+    elif request.ws_protocol == "test-10":
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-11":
+        resp = "wrong message"
+        if msgutil.receive_message(request) == "client data":
+            resp = "server data"
+        msgutil.send_message(request, six.ensure_text(resp))
+    elif request.ws_protocol == "test-12":
+        msg = msgutil.receive_message(request)
+        if msg == u"a\ufffdb":
+            # converted unpaired surrogate in UTF-16 to UTF-8 OK
+            msgutil.send_message(request, "SUCCESS")
+        else:
+            msgutil.send_message(
+                request,
+                "FAIL got '" + msg + "' instead of string with replacement char'",
+            )
+    elif request.ws_protocol == "test-13":
+        # first one binary message containing the byte 0x61 ('a')
+        request.connection.write(b"\xff\x01\x61")
+        # after a bad utf8 message
+        request.connection.write(b"\x01\x61\xff")
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-14":
+        msgutil.close_connection(request)
+        msgutil.send_message(request, "server data")
+    elif request.ws_protocol == "test-15":
+        # DISABLED: close_connection hasn't supported 2nd 'abort' argument for a
+        # long time.  Passing extra arg was causing exception, which conveniently
+        # caused abort :) but as of pywebsocket v606 raising an exception here no
+        # longer aborts, and there's no obvious way to close TCP connection w/o
+        # sending websocket CLOSE.
+        raise RuntimeError("test-15 should be disabled for now")
+        # msgutil.close_connection(request, True)   # OBSOLETE 2nd arg
+        # return
+    elif request.ws_protocol == "test-17" or request.ws_protocol == "test-21":
+        time.sleep(2)
+        resp = "wrong message"
+        if msgutil.receive_message(request) == "client data":
+            resp = "server data"
+        msgutil.send_message(request, six.ensure_text(resp))
+        time.sleep(2)
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-20":
+        msgutil.send_message(request, "server data")
+        msgutil.close_connection(request)
+    elif request.ws_protocol == "test-34":
+        request.ws_stream.close_connection(1001, "going away now")
+    elif request.ws_protocol == "test-35a":
+        while not request.client_terminated:
+            msgutil.receive_message(request)
+        global test35code
+        test35code = request.ws_close_code
+        global test35reason
+        test35reason = request.ws_close_reason
+    elif request.ws_protocol == "test-35b":
+        request.ws_stream.close_connection(test35code + 1, test35reason)
+    elif request.ws_protocol == "test-37b":
+        while not request.client_terminated:
+            msgutil.receive_message(request)
+        global test37code
+        test37code = request.ws_close_code
+        global test37reason
+        test37reason = request.ws_close_reason
+    elif request.ws_protocol == "test-37c":
+        request.ws_stream.close_connection(test37code, test37reason)
+    elif request.ws_protocol == "test-42":
+        # Echo back 3 messages
+        msgutil.send_message(request, msgutil.receive_message(request))
+        msgutil.send_message(request, msgutil.receive_message(request))
+        msgutil.send_message(request, msgutil.receive_message(request))
+    elif request.ws_protocol == "test-44":
+        rcv = six.ensure_text(msgutil.receive_message(request))
+        # check we received correct binary msg
+        if len(rcv) == 3 and ord(rcv[0]) == 5 and ord(rcv[1]) == 0 and ord(rcv[2]) == 7:
+            # reply with binary msg 0x04
+            msgutil.send_message(request, b"\x00\x04", True, True)
+        else:
+            msgutil.send_message(request, "incorrect binary msg received!")
+    elif request.ws_protocol == "test-45":
+        rcv = msgutil.receive_message(request)
+        # check we received correct binary msg
+        if six.ensure_text(rcv) == "flob":
+            # send back same blob as binary msg
+            msgutil.send_message(request, rcv, True, True)
+        else:
+            msgutil.send_message(
+                request, "incorrect binary msg received: '" + rcv + "'"
+            )
+    elif request.ws_protocol == "test-46":
+        msgutil.send_message(request, "client must drop this if close was called")
+
+    while not request.client_terminated:
+        msgutil.receive_message(request)
diff --git a/dom/websocket/tests/frame_bug1384658.html b/dom/websocket/tests/frame_bug1384658.html
new file mode 100644
index 0000000000..c13cb17f3a
--- /dev/null
+++ b/dom/websocket/tests/frame_bug1384658.html
@@ -0,0 +1,13 @@
+<html>
+<body>
+  <form action="file_bug1384658.html" method="GET" id="form">
+    <input type='submit' name='y'>
+    <input type='hidden' name='x'>
+  </form>
+  <script>
+onload = function() {
+  document.getElementById("form").submit();
+};
+  </script>
+</body>
+</html>
diff --git a/dom/websocket/tests/iframe_websocket_sandbox.html b/dom/websocket/tests/iframe_websocket_sandbox.html
new file mode 100644
index 0000000000..0e6d1d97bf
--- /dev/null
+++ b/dom/websocket/tests/iframe_websocket_sandbox.html
@@ -0,0 +1,65 @@
+<html><body>
+<iframe id="frame" sandbox="allow-scripts allow-popups"></iframe>
+<script type="application/javascript">
+onmessage = function(e) {
+  parent.postMessage(e.data, '*');
+}
+
+var ifr = document.getElementById('frame');
+
+if (location.search == '?nested') {
+  var url = new URL(location);
+  url.search = "";
+  ifr.src = url.href;
+} else if (location.search == '?popup') {
+  var url = new URL(location);
+  url.search = "?opener";
+
+  ifr.srcdoc = "<html><script>" +
+    "window.open('" + url.href + "', 'foobar');" +
+    "onmessage = function(e) { " +
+    "  parent.postMessage(e.data, '*'); " +
+    "}" +
+  "</scr" + "ipt></html>";
+} else if (location.search == '?opener') {
+  try{
+    var socket = new WebSocket('ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic');
+    socket.onerror = function(e) {
+      opener.postMessage('WS onerror', '*');
+      close();
+    };
+    socket.onopen = function(event) {
+      opener.postMessage('WS onopen', '*');
+      close();
+    };
+  } catch(e) {
+    if (e.name == 'SecurityError') {
+      opener.postMessage('WS Throws!', '*');
+    } else {
+      opener.postMessage('WS Throws something else!', '*');
+    }
+    close();
+  }
+} else {
+  ifr.srcdoc = `
+  <html><script>
+  try{
+    var socket = new WebSocket('ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic');
+    socket.onerror = function(e) {
+      parent.postMessage('WS onerror', '*');
+    };
+    socket.onopen = function(event) {
+      parent.postMessage('WS onopen', '*');
+    };
+  } catch(e) {
+    if (e.name == 'SecurityError') {
+      parent.postMessage('WS Throws!', '*');
+    } else {
+      parent.postMessage('WS Throws something else!', '*');
+    }
+  }
+  </scr`+`ipt>
+  </html>`;
+}
+</script>
+</body></html>
diff --git a/dom/websocket/tests/iframe_websocket_wss.html b/dom/websocket/tests/iframe_websocket_wss.html
new file mode 100644
index 0000000000..71945a30d9
--- /dev/null
+++ b/dom/websocket/tests/iframe_websocket_wss.html
@@ -0,0 +1,35 @@
+<html><body>
+Creating WebSocket
+<script type="application/javascript">
+onmessage = function(e) {
+  parent.postMessage(e.data, '*');
+}
+
+try{
+    let socket;
+    if (location.search == '?insecure') {
+      socket = new WebSocket('ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello');
+    }
+    else {
+      socket = new WebSocket('wss://example.com/tests/dom/websocket/tests/file_websocket_hello');
+    }
+    socket.onerror = function(e) {
+      parent.postMessage('WS onerror', '*');
+      close();
+    };
+    socket.onopen = function(event) {
+      socket.close();
+      parent.postMessage('WS onopen', '*');
+      close();
+    };
+  } catch(e) {
+    if (e.name == 'SecurityError') {
+      parent.postMessage('SecurityError', '*');
+    } else {
+      parent.postMessage('WS Throws something else!', '*');
+    }
+    close();
+  }
+
+</script>
+</body></html>
diff --git a/dom/websocket/tests/mochitest.ini b/dom/websocket/tests/mochitest.ini
new file mode 100644
index 0000000000..50968d7626
--- /dev/null
+++ b/dom/websocket/tests/mochitest.ini
@@ -0,0 +1,64 @@
+[DEFAULT]
+skip-if =
+  toolkit == 'android' # bug 982828
+  http3
+support-files =
+  !/dom/events/test/event_leak_utils.js
+  file_websocket_basic_wsh.py
+  file_websocket_hello_wsh.py
+  file_websocket_http_resource.txt
+  file_websocket_permessage_deflate_wsh.py
+  file_websocket_permessage_deflate_disabled_wsh.py
+  file_websocket_permessage_deflate_rejected_wsh.py
+  file_websocket_permessage_deflate_params_wsh.py
+  file_websocket_wsh.py
+  websocket_helpers.js
+  websocket_tests.js
+  websocket_worker_helpers.js
+
+[test_bug1081686.html]
+[test_bug1384658.html]
+support-files = window_bug1384658.html frame_bug1384658.html file_bug1384658.html
+[test_event_listener_leaks.html]
+support-files = file_websocket_bigBlob_wsh.py
+skip-if = (os == "win" && processor == "aarch64") #bug 1535784
+[test_websocket1.html]
+[test_websocket2.html]
+[test_websocket3.html]
+[test_websocket4.html]
+[test_websocket5.html]
+[test_websocket_basic.html]
+[test_websocket_hello.html]
+[test_websocket_permessage_deflate.html]
+[test_websocket_sandbox.html]
+support-files = iframe_websocket_sandbox.html
+[test_websocket_mixed_content.html]
+scheme=https
+support-files = iframe_websocket_wss.html
+[test_websocket_mixed_content_opener.html]
+scheme=https
+support-files = window_websocket_wss.html
+[test_worker_websocket1.html]
+support-files = websocket_worker1.js
+[test_worker_websocket2.html]
+support-files = websocket_worker2.js
+skip-if = socketprocess_networking # bug 1787044
+[test_worker_websocket3.html]
+support-files = websocket_worker3.js
+[test_worker_websocket4.html]
+support-files = websocket_worker4.js
+[test_worker_websocket5.html]
+support-files = websocket_worker5.js
+[test_worker_websocket_basic.html]
+support-files = websocket_basic_worker.js
+[test_worker_websocket_https.html]
+support-files = websocket_worker_https.html websocket_https_worker.js
+[test_worker_websocket_loadgroup.html]
+support-files = websocket_loadgroup_worker.js
+[test_websocket_sharedWorker.html]
+support-files = websocket_sharedWorker.js
+[test_websocket_bigBlob.html]
+support-files = file_websocket_bigBlob_wsh.py
+[test_websocket_longString.html]
+[test_websocket_no_duplicate_packet.html]
+scheme = https
diff --git a/dom/websocket/tests/test_bug1081686.html b/dom/websocket/tests/test_bug1081686.html
new file mode 100644
index 0000000000..debcd97184
--- /dev/null
+++ b/dom/websocket/tests/test_bug1081686.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+-->
+<head>
+  <title>bug 1081686</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+var ws;
+
+function forcegc()
+{
+  SpecialPowers.forceGC();
+  SpecialPowers.gc();
+  setTimeout(function()
+  {
+    SpecialPowers.gc();
+  }, 0);
+}
+
+function testWebSocket () {
+  ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello");
+  ws.onopen = function(e) {
+    ws.send("data");
+  }
+  ws.onclose = function(e) {
+    forcegc();
+    setTimeout(function() {
+      is(ws.readyState, 3, 'WebSocket is closed');
+      is(ws.bufferedAmount, 0, 'WebSocket.bufferedAmount should be empty.');
+      is(ws.binaryType, 'blob', 'WebSocket.binaryType is blob');
+      ws.binaryType = 'arraybuffer';
+      is(ws.binaryType, 'arraybuffer', 'WebSocket.binaryType is arraybuffer');
+      is(ws.url, 'ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello', 'WebSocket.url is correct');
+      ws.close();
+      ws.send('foobar');
+      SimpleTest.finish();
+    }, 1000);
+  }
+
+  ws.onerror = function(e) {
+    ok(false, "onerror called!");
+    SimpleTest.finish();
+  }
+  ws.onmessage = function(e) {
+    is(e.data, "Hello world!", "Wrong data");
+    ws.close();
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+
+</script>
+</pre>
+<div>
+
+
+</div>
+
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_bug1384658.html b/dom/websocket/tests/test_bug1384658.html
new file mode 100644
index 0000000000..dd90a0d5d3
--- /dev/null
+++ b/dom/websocket/tests/test_bug1384658.html
@@ -0,0 +1,54 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1384658
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1384658</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script type="application/javascript">
+
+  /** Test for Bug 1384658 **/
+
+function test_frameset() {
+  var bc = new BroadcastChannel("test_channel");
+  bc.postMessage("go");
+  bc.onmessage = ev => {
+    ok(ev.data.success, "We didn't hang");
+    bc.close();
+    test_window();
+  };
+}
+
+function test_window() {
+  var win = window.open("http://example.com/tests/dom/websocket/tests/window_bug1384658.html",
+                        "_blank", "width=100,height=100");
+  var bc = new BroadcastChannel("test_channel");
+  bc.onmessage = ev => {
+    ok(ev.data.success, "We didn't hang");
+    bc.close();
+    win.close();
+    SimpleTest.finish();
+  };
+}
+
+SimpleTest.waitForExplicitFinish();
+// Use nsICookieService.BEHAVIOR_REJECT_TRACKER to not partition BroadcastChannel
+// by extra first-party domain information.
+SpecialPowers.pushPrefEnv({
+  set: [
+    ["network.cookie.cookieBehavior", 4],
+    // disable third-party storage isolation so the test works as expected
+    ["privacy.partition.always_partition_third_party_non_cookie_storage", false],
+    ["dom.security.https_first", false]
+  ],
+}, test_frameset);
+
+  </script>
+</head>
+<frameset id="frame_set" cols="25%,75%" frameborder="yes" border="5" bordercolor="#008800">
+  <frame id="test_frame" name="test_frame" src="frame_bug1384658.html" marginwidth="20" marginheight="20">
+</frameset>
+</html>
diff --git a/dom/websocket/tests/test_event_listener_leaks.html b/dom/websocket/tests/test_event_listener_leaks.html
new file mode 100644
index 0000000000..9a79fa1354
--- /dev/null
+++ b/dom/websocket/tests/test_event_listener_leaks.html
@@ -0,0 +1,57 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1450358 - Test WebSocket event listener leak conditions</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="/tests/dom/events/test/event_leak_utils.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+// Manipulate WebSocket objects in the frame's context.
+// Its important here that we create a listener callback from
+// the DOM objects back to the frame's global in order to
+// exercise the leak condition.
+async function useWebSocket(contentWindow) {
+  const url = "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_bigBlob";
+  let ws = new contentWindow.WebSocket(url);
+
+  ws.onmessage = _ => {
+    contentWindow.messageCount += 1;
+  };
+
+  contentWindow.openCount = 0;
+  await new Promise((resolve, reject) => {
+    ws.onopen = _ => {
+      contentWindow.openCount += 1;
+      resolve();
+    };
+    ws.onerror = e => {
+      contentWindow.errorCount += 1;
+      reject("websocket error");
+    };
+  });
+
+  is(contentWindow.openCount, 1, "open should be received");
+}
+
+async function runTest() {
+  try {
+    await checkForEventListenerLeaks("WebSocket", useWebSocket);
+  } catch (e) {
+    ok(false, e);
+  } finally {
+    SimpleTest.finish();
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+addEventListener("load", runTest, { once: true });
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket1.html b/dom/websocket/tests/test_websocket1.html
new file mode 100644
index 0000000000..1844a67f58
--- /dev/null
+++ b/dom/websocket/tests/test_websocket1.html
@@ -0,0 +1,42 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <script type="text/javascript" src="websocket_tests.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<script class="testbody" type="text/javascript">
+
+var tests = [
+  test1,  // client tries to connect to a http scheme location;
+  test2,  // assure serialization of the connections;
+  test3,  // client tries to connect to an non-existent ws server;
+  test4,  // client tries to connect using a relative url;
+  test5,  // client uses an invalid protocol value;
+  test6,  // counter and encoding check;
+  test7,  // onmessage event origin property check
+  test8,  // client calls close() and the server sends the close frame (with no
+          // code or reason) in acknowledgement;
+  test9,  // client closes the connection before the ws connection is established;
+  test10, // client sends a message before the ws connection is established;
+];
+
+function testWebSocket() {
+  doTest();
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+
+<div id="feedback">
+</div>
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket2.html b/dom/websocket/tests/test_websocket2.html
new file mode 100644
index 0000000000..afbbaba62f
--- /dev/null
+++ b/dom/websocket/tests/test_websocket2.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <script type="text/javascript" src="websocket_tests.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<script class="testbody" type="text/javascript">
+
+var tests = [
+  test11, // a simple hello echo;
+  test12, // client sends a message containing unpaired surrogates
+  test13, //server sends an invalid message;
+  test14, // server sends the close frame, it doesn't close the tcp connection
+          // and it keeps sending normal ws messages;
+  test15, // server closes the tcp connection, but it doesn't send the close
+          // frame;
+  test16, // client calls close() and tries to send a message;
+  test17, // see bug 572975 - all event listeners set
+  test18, // client tries to connect to an http resource;
+  test19, // server closes the tcp connection before establishing the ws
+          // connection;
+  test20, // see bug 572975 - only on error and onclose event listeners set
+];
+
+function testWebSocket() {
+  doTest();
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+
+<div id="feedback">
+</div>
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket3.html b/dom/websocket/tests/test_websocket3.html
new file mode 100644
index 0000000000..cc2e091fda
--- /dev/null
+++ b/dom/websocket/tests/test_websocket3.html
@@ -0,0 +1,44 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <script type="text/javascript" src="websocket_tests.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<script class="testbody" type="text/javascript">
+
+var tests = [
+ test21, // see bug 572975 - same as test 17, but delete strong event listeners
+         // when receiving the message event;
+ test22, // server takes too long to establish the ws connection;
+ test23, // should detect WebSocket on window object;
+ test24, // server rejects sub-protocol string
+ test25, // ctor with valid empty sub-protocol array
+ test26, // ctor with invalid sub-protocol array containing 1 empty element
+ test27, // ctor with invalid sub-protocol array containing an empty element in
+         // list
+ test28, // ctor using valid 1 element sub-protocol array
+ test29, // ctor using all valid 5 element sub-protocol array
+ test30, // ctor using valid 1 element sub-protocol array with element server
+         // will reject
+];
+
+function testWebSocket() {
+  doTest();
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+
+<div id="feedback">
+</div>
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket4.html b/dom/websocket/tests/test_websocket4.html
new file mode 100644
index 0000000000..186a434ab3
--- /dev/null
+++ b/dom/websocket/tests/test_websocket4.html
@@ -0,0 +1,42 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <script type="text/javascript" src="websocket_tests.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<script class="testbody" type="text/javascript">
+
+var tests = [
+  test31, // ctor using valid 2 element sub-protocol array with 1 element server
+          // will reject and one server will accept
+  test32, // ctor using invalid sub-protocol array that contains duplicate items
+  test33, // test for sending/receiving custom close code (but no close reason)
+  test34, // test for receiving custom close code and reason
+  test35, // test for sending custom close code and reason
+  test36, // negative test for sending out of range close code
+  test37, // negative test for too long of a close reason
+  test38, // ensure extensions attribute is defined
+  test39, // a basic wss:// connectivity test
+  test40, // negative test for wss:// with no cert
+];
+
+function testWebSocket() {
+  doTest();
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+
+<div id="feedback">
+</div>
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket5.html b/dom/websocket/tests/test_websocket5.html
new file mode 100644
index 0000000000..d86752ed5a
--- /dev/null
+++ b/dom/websocket/tests/test_websocket5.html
@@ -0,0 +1,41 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <script type="text/javascript" src="websocket_tests.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<script class="testbody" type="text/javascript">
+
+var tests = [
+  test41, // HSTS
+  test42, // non-char utf-8 sequences
+  test43, // Test setting binaryType attribute
+  test44, // Test sending/receving binary ArrayBuffer
+  test45, // Test sending/receving binary Blob
+  test46, // Test that we don't dispatch incoming msgs once in CLOSING state
+  test47, // Make sure onerror/onclose aren't called during close()
+  test48, // see bug 1227136 - client calls close() from onopen() and waits
+          // until WebSocketChannel::mSocketIn is nulled out on socket thread
+  test49, // Test that we fail if subprotocol returned from server doesn't match
+];
+
+function testWebSocket() {
+  doTest();
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+
+<div id="feedback">
+</div>
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_basic.html b/dom/websocket/tests/test_websocket_basic.html
new file mode 100644
index 0000000000..2ae2e690ac
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_basic.html
@@ -0,0 +1,289 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Basic WebSocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+
+<body onload="testWebSocket()">
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=472529">Mozilla Bug 472529</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+const kUrl = "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic";
+
+var gTestElement;
+var ws;
+
+function forcegc() {
+  SpecialPowers.forceGC();
+  SpecialPowers.gc();
+}
+
+function testWebSocket() {
+  gTestElement = document.getElementById("test");
+
+  SimpleTest.executeSoon(testWebSocket1);
+}
+
+/**
+ * Sends message keywords, then receives their values.
+ */
+function testWebSocket1() {
+  gTestElement.textContent = "Running testWebSocket1()";
+
+  var results = ["test",
+                 "/tests/dom/websocket/tests/file_websocket_basic",
+                 "http://mochi.test:8888",
+                 "end"];
+
+  ws = new WebSocket(kUrl, "test");
+  is(ws.url, kUrl, "[1] WebSocket.url");
+  ws.onopen = function(e) {
+    const params = ["protocol", "resource", "origin", "end"];
+
+    gTestElement.textContent += "\nSending :";
+    for (var i = 0; i < params.length; ++i) {
+      gTestElement.textContent += " " + params[i];
+      ws.send(params[i]);
+    }
+
+    // Set this before onmessage() is called, so it is displayed once only.
+    gTestElement.textContent += "\nReceived:";
+  };
+  ws.onclose = function(e) {
+    is(results.length, 0, "[1] Number of unreceived messages");
+    ok(e.wasClean, "[1] Connection closed cleanly");
+
+    SimpleTest.executeSoon(testWebSocket2);
+  };
+  ws.onerror = function(e) {
+    ok(false, "[1] onerror() should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+  ws.onmessage = function(e) {
+    is(e.data, results[0], "[1] Received message");
+    gTestElement.textContent += " " + e.data;
+    results.shift();
+  };
+}
+
+/**
+ * Sends 1000+1 test messages, then receives them.
+ */
+function testWebSocket2() {
+  gTestElement.textContent = "Running testWebSocket2()";
+
+  const displayInterval = 100;
+  const testCount = 1000;
+  const testMessage = "test message 2.";
+
+  var messageCount = 0;
+
+  ws = new WebSocket(kUrl, "test");
+  ws.onopen = function(e) {
+    gTestElement.textContent += "\nSending :";
+    for (var i = 1; i <= testCount; ++i) {
+      if (i % displayInterval == 1) {
+        gTestElement.textContent += " " + i;
+      }
+      ws.send(testMessage + i);
+    }
+    gTestElement.textContent += " end";
+    ws.send("end");
+
+    // Set this before onmessage() is called, so it is displayed once only.
+    gTestElement.textContent += "\nReceived:";
+  };
+  ws.onclose = function(e) {
+    is(messageCount, testCount + 1, "[2] Number of received messages");
+    ok(e.wasClean, "[2] Connection closed cleanly");
+
+    SimpleTest.executeSoon(testWebSocket3);
+  };
+  ws.onerror = function(e) {
+    ok(false, "[2] onerror() should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+  ws.onmessage = function(e) {
+    ++messageCount;
+    if (messageCount > testCount)
+      is(e.data, "end", "[2] Received message");
+    else
+      is(e.data, testMessage + messageCount, "[2] Received message");
+    if (messageCount % displayInterval == 1) {
+      gTestElement.textContent += " " + messageCount;
+    }
+  };
+}
+
+/**
+ * Sends testcount+1 test messages, then receives them, calling forcegc() at each step.
+ */
+function testWebSocket3() {
+  gTestElement.textContent = "Running testWebSocket3() [can take a little while]";
+
+  const displayInterval = 10;
+  const testCount = 10;
+  const testMessage = "test message 3.";
+
+  var messageCount = 0;
+
+  ws = new WebSocket(kUrl, "test");
+  // Set this before onopen() is called,
+  // otherwise its display would be delayed by forcegc() calls...
+  gTestElement.textContent += "\nSending :";
+  ws.onopen = function(e) {
+    for (var i = 1; i <= testCount; ++i) {
+      forcegc();
+      if (i % displayInterval == 1) {
+        // Actual display is delayed by forcegc() calls...
+        gTestElement.textContent += " " + i;
+      }
+      ws.send(testMessage + i);
+    }
+    forcegc();
+    gTestElement.textContent += " end";
+    ws.send("end");
+
+    // Set this before onmessage() is called, so it is displayed once only.
+    gTestElement.textContent += "\nReceived:";
+  };
+  ws.onclose = function(e) {
+    is(messageCount, testCount + 1, "[3] Number of received messages");
+    ok(e.wasClean, "[3] Connection closed cleanly");
+
+    SimpleTest.executeSoon(testWebSocket4);
+  };
+  ws.onerror = function(e) {
+    ok(false, "[3] onerror() should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+  ws.onmessage = function(e) {
+    forcegc();
+    ++messageCount;
+    if (messageCount > testCount)
+      is(e.data, "end", "[3] Received message");
+    else
+      is(e.data, testMessage + messageCount, "[3] Received message");
+    if (messageCount % displayInterval == 1) {
+      // Actual display is delayed by forcegc() call(s)...
+      gTestElement.textContent += " " + messageCount;
+    }
+  };
+}
+
+/**
+ * Sends a huge test message, then receives it, then closes the WebSocket from client-side.
+ */
+function testWebSocket4() {
+  gTestElement.textContent = "Running testWebSocket4()";
+
+  // String length = 13 + ((10,000 - 1) * 26) + 11 = 259,998 = almost 254 KiB.
+  const longString = "messageStart " + new Array(10000).join(" -huge WebSocket message- ") + " messageEnd";
+
+  ws = new WebSocket(kUrl, "test");
+  ws.onopen = function(e) {
+    is(this, ws, "[4, onopen()] 'this' should point to the WebSocket.");
+    gTestElement.textContent += "\nSending the huge message";
+    ws.send(longString);
+  };
+  ws.onclose = function(e) {
+    is(this, ws, "[4, onclose()] 'this' should point to the WebSocket.");
+    ok(e.wasClean, "[4] Connection closed cleanly");
+
+    SimpleTest.executeSoon(testWebSocket5);
+  };
+  ws.onerror = function(e) {
+    is(this, ws, "[4, onerror()] 'this' should point to the WebSocket.");
+    ok(false, "[4, onerror()] should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+  ws.onmessage = function(e) {
+    is(this, ws, "[4, onmessage()] 'this' should point to the WebSocket.");
+    // Do not use |is(e.data, longString, "...");| that results in a _very_ long line.
+    is(e.data.length, longString.length, "[4] Length of received message");
+    ok(e.data == longString, "[4] Content of received message");
+    gTestElement.textContent += "\nReceived the huge message";
+    this.close();
+  };
+}
+
+/**
+ * Closes the WebSocket from client-side, then sends a test message that should be buffered.
+ */
+function testWebSocket5() {
+  gTestElement.textContent = "Running testWebSocket5()";
+
+  ws = new WebSocket(kUrl, "test");
+  ws.onopen = function(e) {
+    is(this.bufferedAmount, 0, "[5] Length of empty buffer before closing");
+    this.close();
+  };
+  ws.onclose = function(e) {
+    ok(e.wasClean, "[5] Connection closed cleanly");
+    is(this.bufferedAmount, 0, "[5] Length of empty buffer after closing");
+
+    var msg = "test message to be buffered";
+    this.send(msg);
+    is(this.bufferedAmount, msg.length, "[5] Length of buffered message sent after closing");
+
+    gTestElement.textContent += "\ntestWebSocket5() completed";
+
+    SimpleTest.executeSoon(testWebSocket6);
+  };
+  ws.onerror = function(e) {
+    ok(false, "[5] onerror() should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+}
+
+function testWebSocket6() {
+  gTestElement.textContent = "Running testWebSocket6()";
+
+  var msgReceived = false;
+  ws = new WebSocket(kUrl, "test");
+  ws.onopen = function(e) {
+    gTestElement.textContent += "\nSending ©";
+    ws.send("©");
+    gTestElement.textContent += " end";
+    ws.send("end");
+  };
+  ws.onclose = function(e) {
+    ok(msgReceived, "[6] Number of received messages");
+    ok(e.wasClean, "[6] Connection closed cleanly");
+
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+  ws.onerror = function(e) {
+    ok(false, "[6] onerror() should not have been called!");
+    gTestElement.textContent += "\nonerror() should not have been called!";
+    SimpleTest.executeSoon(SimpleTest.finish);
+  };
+
+  ws.onmessage = function(e) {
+    if (msgReceived) {
+      is(e.data, "end", "[6] Received message");
+    } else {
+      gTestElement.textContent += "\nReceived: " + e.data;
+      is(e.data, "©", "[6] Received message");
+      msgReceived = true;
+    }
+  };
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_bigBlob.html b/dom/websocket/tests/test_websocket_bigBlob.html
new file mode 100644
index 0000000000..9db01d6a7f
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_bigBlob.html
@@ -0,0 +1,55 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test - big blob on content side</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+
+var ws = CreateTestWS("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_bigBlob");
+is(ws.readyState, 0, "Initial readyState is 0");
+ws.binaryType = "blob";
+
+ws.onopen = function() {
+  is(ws.readyState, 1, "Open readyState is 1");
+  ws.send(new Blob([new Array(1024*1024).join('123456789ABCDEF')]));
+}
+
+let receivedBlob;
+ws.onmessage = function(e) {
+  ok(e.data instanceof Blob, "We should be receiving a Blob");
+  receivedBlob = e.data;
+  ws.close();
+}
+
+ws.onclose = function(e) {
+  is(ws.readyState, 3, "Close readyState is 3");
+
+  // check blob contents
+  var reader = new FileReader();
+  reader.onload = function(event) {
+    is(reader.result, new Array(1024*1024).join('123456789ABCDEF'), "All data matches");
+  }
+
+  reader.onerror = function(event) {
+    ok(false, "Something bad happen.");
+  }
+
+  reader.onloadend = function(event) {
+    SimpleTest.finish();
+  }
+
+  reader.readAsBinaryString(receivedBlob);
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_frame.html b/dom/websocket/tests/test_websocket_frame.html
new file mode 100644
index 0000000000..6c95419bc2
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_frame.html
@@ -0,0 +1,161 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+-->
+<head>
+  <title>Basic websocket frame interception test</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+
+const URI = "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic";
+
+var frameReceivedCounter = 0;
+var frameSentCounter = 0;
+var webSocketCreatedCounter = 0;
+var webSocketOpenedCounter = 0;
+var webSocketMessageAvailableCounter = 0;
+var webSocketClosedCounter = 0;
+
+var tests = [
+  { payload: "Hello world!" },
+  { payload: (function() { var buffer = ""; for (var i = 0; i < 120; ++i) buffer += i; return buffer; }()) },
+]
+
+var innerId = window.windowGlobalChild.innerWindowId;
+ok(innerId, "We have a valid innerWindowID: " + innerId);
+
+var service = Cc["@mozilla.org/websocketevent/service;1"]
+                .getService(Ci.nsIWebSocketEventService);
+ok(!!service, "We have the nsIWebSocketEventService");
+
+var listener = {
+  QueryInterface: ChromeUtils.generateQI(["nsIWebSocketEventListener"]),
+
+  webSocketCreated(aWebSocketSerialID, aURI, aProtocols) {
+    info("WebSocketCreated");
+
+    is(aURI, URI, "URI matches");
+    is(aProtocols, "frame", "Protocol matches");
+
+    webSocketCreatedCounter++;
+  },
+
+  webSocketOpened(aWebSocketSerialID, aEffectiveURI, aProtocols, aExtensions, httpChannelId) {
+    info("WebSocketOpened");
+
+    is(aEffectiveURI, URI, "EffectiveURI matches");
+    is(aProtocols, "frame", "Protocol matches");
+    is(aExtensions, "permessage-deflate", "No extensions");
+    ok(httpChannelId > 0, "Channel ID received");
+
+    webSocketOpenedCounter++;
+  },
+
+  webSocketMessageAvailable(aWebSocketSerialID, aData, aMessageType) {
+    info("WebSocketMessageAvailable");
+
+    if (tests.length) {
+      is(aData, tests[0].payload, "Message matches!");
+      is(aMessageType, Ci.nsIWebSocketEventListener.TYPE_STRING, "The type is 'string'");
+
+      webSocketMessageAvailableCounter++;
+
+      tests.shift();
+      if (tests.length) {
+        ws.send(tests[0].payload);
+      } else {
+        ws.send("end");
+      }
+    }
+  },
+
+  webSocketClosed(aWebSocketSerialID, aWasClean,
+                            aCode, aReason) {
+    info("WebSocketClosed");
+
+    ok(aWasClean, "The socket is closed in a clean state");
+    is(aCode, 1000, "Exit code 1000");
+    ok(!aReason.length, "No reason");
+
+    webSocketClosedCounter++;
+    checkListener();
+  },
+
+  frameReceived(aWebSocketSerialID, aFrame) {
+    ok(!!aFrame, "We have received a frame");
+
+    if (tests.length) {
+      ok(aFrame.timeStamp, "Checking timeStamp: " + aFrame.timeStamp);
+      is(aFrame.finBit, true, "Checking finBit");
+      is(aFrame.rsvBit1, true, "Checking rsvBit1");
+      is(aFrame.rsvBit2, false, "Checking rsvBit2");
+      is(aFrame.rsvBit3, false, "Checking rsvBit3");
+      is(aFrame.opCode, aFrame.OPCODE_TEXT, "Checking opCode");
+      is(aFrame.maskBit, false, "Checking maskBit");
+      is(aFrame.mask, 0, "Checking mask");
+      is(aFrame.payload, tests[0].payload, "Checking payload: " + aFrame.payload);
+    }
+
+    frameReceivedCounter++;
+  },
+
+  frameSent(aWebSocketSerialID, aFrame) {
+    ok(!!aFrame, "We have sent a frame");
+
+    if (tests.length) {
+      ok(aFrame.timeStamp, "Checking timeStamp: " + aFrame.timeStamp);
+      is(aFrame.finBit, true, "Checking finBit");
+      is(aFrame.rsvBit1, true, "Checking rsvBit1");
+      is(aFrame.rsvBit2, false, "Checking rsvBit2");
+      is(aFrame.rsvBit3, false, "Checking rsvBit3");
+      is(aFrame.opCode, aFrame.OPCODE_TEXT, "Checking opCode");
+      is(aFrame.maskBit, true, "Checking maskBit");
+      ok(!!aFrame.mask, "Checking mask: " + aFrame.mask);
+      is(aFrame.payload, tests[0].payload, "Checking payload: " + aFrame.payload);
+    }
+
+    frameSentCounter++;
+  }
+};
+
+service.addListener(innerId, listener);
+ok(true, "Listener added");
+
+function checkListener() {
+  service.removeListener(innerId, listener);
+
+  ok(frameReceivedCounter, "We received some frames!");
+  ok(frameSentCounter, "We sent some frames!");
+  ok(webSocketCreatedCounter, "We have a create notification");
+  ok(webSocketOpenedCounter, "We have a open notification");
+  ok(webSocketMessageAvailableCounter, "We have a messageAvailable notification");
+  ok(webSocketClosedCounter, "We have a close notification");
+  SimpleTest.finish();
+}
+
+var ws = new WebSocket(URI, "frame");
+ws.onopen = function(e) {
+  info("onopen");
+
+  ws.send(tests[0].payload);
+}
+
+ws.onclose = function(e) {
+  info("onclose");
+}
+
+ws.onmessage = function(e) {
+  info("onmessage");
+  if (tests.length) {
+    is(e.data, tests[0].payload, "Wrong data");
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_hello.html b/dom/websocket/tests/test_websocket_hello.html
new file mode 100644
index 0000000000..8508fba97b
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_hello.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+-->
+<head>
+  <title>Basic websocket test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="testWebSocket()">
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=472529">Mozilla Bug </a>
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+var ws;
+
+function testWebSocket () {
+  ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello");
+  ws.onopen = function(e) {
+    ws.send("data");
+  }
+  ws.onclose = function(e) {
+  }
+  ws.onerror = function(e) {
+    ok(false, "onerror called!");
+    SimpleTest.finish();
+  }
+  ws.onmessage = function(e) {
+    is(e.data, "Hello world!", "Wrong data");
+    ws.close();
+    SimpleTest.finish();
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+<div>
+
+
+</div>
+
+
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_longString.html b/dom/websocket/tests/test_websocket_longString.html
new file mode 100644
index 0000000000..78c8e471c7
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_longString.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test - big blob on content side</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+
+var ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_basic", "test");
+is(ws.readyState, 0, "Initial readyState is 0");
+
+const longString = new Array(1024*1024).join('123456789ABCDEF');
+
+ws.onopen = function(e) {
+  is(this, ws, "[onopen()] 'this' should point to the WebSocket.");
+  ws.send(longString);
+};
+
+ws.onclose = function(e) {
+  is(this, ws, "[onclose()] 'this' should point to the WebSocket.");
+  ok(e.wasClean, "Connection closed cleanly");
+
+  SimpleTest.executeSoon(SimpleTest.finish);
+};
+
+ws.onerror = function(e) {
+  is(this, ws, "[onerror()] 'this' should point to the WebSocket.");
+  ok(false, "onerror()] should not have been called!");
+  SimpleTest.executeSoon(SimpleTest.finish);
+};
+
+ws.onmessage = function(e) {
+  is(this, ws, "[onmessage()] 'this' should point to the WebSocket.");
+  // Do not use |is(e.data, longString, "...");| that results in a _very_ long line.
+  is(e.data.length, longString.length, "Length of received message");
+  ok(e.data === longString, "Content of received message");
+  this.close();
+};
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_mixed_content.html b/dom/websocket/tests/test_websocket_mixed_content.html
new file mode 100644
index 0000000000..bc2ac40188
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_mixed_content.html
@@ -0,0 +1,96 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket mixed content tests - load secure and insecure websockets</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<div id="container"></div>
+<iframe id="frame" sandbox="allow-scripts"></iframe>
+<script class="testbody" type="text/javascript">
+
+let iFrameTests = [testWebSocketSecure, testWebSocketInsecure, testSameOriginSandboxInsecure, testSameOriginSandboxSecure, testCrossOriginSandboxInsecure, testCrossOriginSandboxSecure];
+
+function nextIFrameTest() {
+  if(!iFrameTests.length) {
+    document.getElementById("frame").removeAttribute("src");
+    document.getElementById("frame").remove();
+    SimpleTest.finish();
+  }
+  else {
+    let test = iFrameTests.shift();
+    test();
+  }
+}
+
+function testWebSockets () {
+  nextIFrameTest();
+}
+
+function testWebSocketSecure () {
+  let ws = CreateTestWS("wss://example.com/tests/dom/websocket/tests/file_websocket_hello");
+  ws.onopen = function(e) {
+    ws.send("data");
+  }
+  ws.onmessage = function(e) {
+    is(e.data, "Hello world!", "Wrong data");
+    ws.close();
+    nextIFrameTest();
+  }
+}
+
+// Negative test: this should fail as the page was loaded over https
+function testWebSocketInsecure () {
+  try {
+    let ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello");
+    ok(false, "Should throw DOMException");
+  } catch (e) {
+    ok(e instanceof DOMException, "DOMException thrown ");
+    nextIFrameTest();
+  }
+}
+
+// Negative test: this should fail as the page was loaded over https
+function testSameOriginSandboxInsecure() {
+  document.getElementById("frame").src = "https://example.com/tests/dom/websocket/tests/iframe_websocket_wss.html?insecure";
+  onmessage = function(e) {
+    is(e.data, "SecurityError", "ws://URI cannot be used when loaded over https");
+    nextIFrameTest();
+  }
+}
+
+function testSameOriginSandboxSecure() {
+  document.getElementById("frame").src = "https://example.com/tests/dom/websocket/tests/iframe_websocket_wss.html"
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "wss://URI opened");
+    nextIFrameTest();
+  }
+}
+
+// Negative test: this should fail as the page was loaded over https
+function testCrossOriginSandboxInsecure() {
+  document.getElementById("frame").src = "https://example.org/tests/dom/websocket/tests/iframe_websocket_wss.html?insecure";
+  onmessage = function(e) {
+    is(e.data, "SecurityError", "ws://URI cannot be used when loaded over https");
+    nextIFrameTest();
+  }
+}
+
+function testCrossOriginSandboxSecure() {
+  document.getElementById("frame").src = "https://example.org/tests/dom/websocket/tests/iframe_websocket_wss.html"
+
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "wss://URI opened");
+    nextIFrameTest();
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+testWebSockets();
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_mixed_content_opener.html b/dom/websocket/tests/test_websocket_mixed_content_opener.html
new file mode 100644
index 0000000000..7db0325825
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_mixed_content_opener.html
@@ -0,0 +1,139 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket mixed content opener tests - load secure and insecure websockets in secure and insecure iframes through secure and insecure opened windows</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<div id="container"></div>
+<script class="testbody" type="text/javascript">
+
+let tests = [ testSecureWindowWSS, testSecureWindowWS, testInsecureWindowWSS, testInsecureWindowWS,
+              testSecureWindowSecureIframeWSS, testSecureWindowSecureIframeWS, testSecureWindowInsecureIframeWSS, testSecureWindowInsecureIframeWS,
+              testInsecureWindowSecureIframeWSS, testInsecureWindowSecureIframeWS, testInsecureWindowInsecureIframeWSS, testInsecureWindowInsecureIframeWS]
+
+function nextTest() {
+  if(!tests.length) {
+    SimpleTest.finish();
+  }
+  else {
+    let test = tests.shift();
+    test();
+  }
+}
+
+function testWebSockets () {
+  SimpleTest.waitForExplicitFinish();
+  nextTest();
+}
+
+function cleanupAndLaunchNextTest(win) {
+    win.close();
+    nextTest();
+}
+
+function testSecureWindowWSS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "wss://URI opened");
+    cleanupAndLaunchNextTest(win);
+   }
+}
+
+function testSecureWindowWS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html?insecure", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "SecurityError", "ws://URI cannot be used when loaded over https");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testInsecureWindowWSS() {
+    let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+    onmessage = function(e) {
+      is(e.data, "WS onopen", "wss://URI opened");
+      cleanupAndLaunchNextTest(win);
+    }
+}
+
+function testInsecureWindowWS() {
+  let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html?insecure", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "ws://URI opened");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testSecureWindowSecureIframeWSS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html?https_iframe_wss", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "ws://URI opened");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testSecureWindowSecureIframeWS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html?https_iframe_ws", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "SecurityError", "ws://URI cannot be used when loaded over https");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testSecureWindowInsecureIframeWSS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html?http_iframe_wss", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "Error - iframe not loaded", "http iframe cannot be loaded in secure context (mixed content)");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testSecureWindowInsecureIframeWS() {
+  let win = window.open("https://example.com/tests/dom/websocket/tests/window_websocket_wss.html?http_iframe_ws", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "Error - iframe not loaded", "http iframe cannot be loaded in secure context (mixed content)");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testInsecureWindowSecureIframeWSS() {
+  let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html?https_iframe_wss", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "ws://URI opened");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testInsecureWindowSecureIframeWS() {
+  let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html?https_iframe_ws", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "SecurityError", "ws://URI cannot be used when loaded from an https iframe");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testInsecureWindowInsecureIframeWSS() {
+  let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html?http_iframe_wss", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "ws://URI opened");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+function testInsecureWindowInsecureIframeWS() {
+  let win = window.open("http://example.com/tests/dom/websocket/tests/window_websocket_wss.html?http_iframe_ws", '_blank', 'location=yes,height=570,width=520,scrollbars=yes,status=yes');
+  onmessage = function(e) {
+    is(e.data, "WS onopen", "ws://URI opened");
+    cleanupAndLaunchNextTest(win);
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+testWebSockets();
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_no_duplicate_packet.html b/dom/websocket/tests/test_websocket_no_duplicate_packet.html
new file mode 100644
index 0000000000..7b2b0fc690
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_no_duplicate_packet.html
@@ -0,0 +1,106 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"></meta>
+  <title>WebSocket test - big blob on content side</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="websocket_helpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+
+// Test steps:
+// 1. Create a websocket and send 8 chunks of 1MB random data.
+// 2. Store the hash of each chunk (1MB of random data).
+// 3. Websocket server returns the same data back.
+// 4. Calculate the hash again and check the hash is the same as the stored one.
+
+function genRandomPayload() {
+  const count = 128;
+  const chunkSize = 64 * 1024;
+  let buffer = new Uint8Array(chunkSize * count);
+  let offset = 0;
+  for (let i = 0; i < count; i++) {
+    let data = new Uint8Array(chunkSize);
+    crypto.getRandomValues(data);
+    buffer.set(data, offset);
+    offset += chunkSize;
+  }
+
+  return buffer;
+}
+
+function genRandomFile() {
+  return new File([genRandomPayload()], "payload.bin", {
+    type: 'application/octet-stream'
+  });
+}
+
+async function toHexString(buffer) {
+  let hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  let hashBytes = new Uint8Array(hashBuffer);
+  let toHex = b => b.toString(16).padStart(2, "0");
+  return Array.from(hashBytes, toHex).join("");
+}
+
+let message_count = 0;
+let sentHashArray = [];
+async function sendFile(file, ws) {
+  const oneMiB = 1 * 1024 * 1024;
+
+  let offset = 0;
+  while (offset < file.size) {
+    let blob = file.slice(offset, offset + oneMiB);
+    let buffer = await blob.arrayBuffer();
+    let hash = await toHexString(buffer);
+    sentHashArray.push(hash);
+    ws.send(buffer);
+    offset += blob.size;
+    message_count++;
+  }
+}
+
+var ws = CreateTestWS("wss://example.com/tests/dom/websocket/tests/file_websocket_bigBlob");
+is(ws.readyState, 0, "Initial readyState is 0");
+ws.binaryType = "blob";
+
+ws.onopen = function() {
+  is(ws.readyState, 1, "Open readyState is 1");
+  let file = genRandomFile();
+  sendFile(file, ws);
+}
+
+let receivedBlobs = [];
+ws.onmessage = function(e) {
+  ok(e.data instanceof Blob, "We should be receiving a Blob");
+  receivedBlobs.push(e.data);
+  message_count--;
+  if (message_count == 0) {
+    ws.close();
+  }
+}
+
+async function checkContent() {
+  is(receivedBlobs.length, sentHashArray.length, "length should be the same");
+  for (let index = 0; index < receivedBlobs.length; index++) {
+    let buffer = await receivedBlobs[index].arrayBuffer();
+    let hash = await toHexString(buffer);
+    is(hash, sentHashArray[index], "hash should be equal");
+  }
+}
+
+ws.onclose = function(e) {
+  is(ws.readyState, 3, "Close readyState is 3");
+  checkContent().then(() => {
+    SimpleTest.finish();
+  });
+}
+
+SimpleTest.requestFlakyTimeout("The web socket tests are really fragile, but avoiding timeouts might be hard, since it's testing stuff on the network. " +
+                               "Expect all sorts of flakiness in this test...");
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_permessage_deflate.html b/dom/websocket/tests/test_websocket_permessage_deflate.html
new file mode 100644
index 0000000000..ecf66419f2
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_permessage_deflate.html
@@ -0,0 +1,110 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Basic test of permessage compression websocket extension</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body onload="loadDeflate()">
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=792831">Mozilla Bug </a>
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+var ws;
+var textMessage = "This is a text message";
+var binaryMessage = "This is a binary message";
+var testIdx = 0;
+var sendText = true;
+
+tests = [
+  // enable PMCE
+  [ true, true, "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_permessage_deflate" ],
+  // disable PMCE
+  [ false, false, "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_permessage_deflate_disabled" ],
+  // server rejects offered PMCE
+  [ true, false, "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_permessage_deflate_rejected" ],
+  // server returns parameters in the handshake
+  [ true, true, "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_permessage_deflate_params" ]
+]
+
+function ab2str(buf) {
+  return String.fromCharCode.apply(null, new Uint16Array(buf));
+}
+
+function str2ab(str) {
+  var buf = new ArrayBuffer(str.length*2);
+  var bufView = new Uint16Array(buf);
+  for (var i=0, strLen=str.length; i<strLen; i++) {
+    bufView[i] = str.charCodeAt(i);
+  }
+  return buf;
+}
+
+function sendMessage() {
+  if (sendText) {
+    ws.send(textMessage);
+  } else {
+    ws.binaryType = "arraybuffer";
+    ws.send(str2ab(binaryMessage));
+  }
+}
+
+function testDeflate() {
+  ws = new WebSocket(tests[testIdx][2]);
+
+  ws.onopen = function(e) {
+    if (tests[testIdx][1]) {
+      is(ws.extensions, "permessage-deflate", "permessage-deflate not negotiated!");
+    } else {
+      is(ws.extensions, "", "permessage-deflate should not be negotiated!");
+    }
+
+    sendMessage();
+  }
+
+  ws.onclose = function(e) {
+    if (!e.wasClean) {
+      ok(false, "Connection should be closed cleanly!");
+      SimpleTest.finish();
+    }
+  }
+
+  ws.onerror = function(e) {
+    ok(false, "onerror called!");
+    SimpleTest.finish();
+  }
+
+  ws.onmessage = function(e) {
+    if (sendText) {
+      is(e.data, textMessage, "Text message not received successfully!");
+      sendText = false;
+      sendMessage();
+    } else {
+      ok(e.data instanceof ArrayBuffer, "Should receive an arraybuffer!");
+      is(ab2str(e.data), binaryMessage, "Binary message not received successfully!");
+      ws.close();
+
+      sendText = true;
+      testIdx++;
+      if (testIdx < tests.length) {
+        loadDeflate();
+      } else {
+        SimpleTest.finish();
+      }
+    }
+  }
+}
+
+function loadDeflate() {
+  SpecialPowers.pushPrefEnv({"set":[['network.websocket.extensions.permessage-deflate', tests[testIdx][0]]]}, testDeflate);
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_sandbox.html b/dom/websocket/tests/test_websocket_sandbox.html
new file mode 100644
index 0000000000..2803186ff0
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_sandbox.html
@@ -0,0 +1,34 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1252751</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<div id="container"></div>
+<iframe id="frame"></iframe>
+<script type="application/javascript">
+var urls = [ "https://example.com/tests/dom/websocket/tests/iframe_websocket_sandbox.html",
+             "https://example.com/tests/dom/websocket/tests/iframe_websocket_sandbox.html?nested",
+             "https://example.com/tests/dom/websocket/tests/iframe_websocket_sandbox.html?popup" ];
+
+onmessage = function(e) {
+  is(e.data, "WS Throws!", "ws://URI cannot be used by a https iframe");
+  runTest();
+}
+
+function runTest() {
+  if (!urls.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  document.getElementById("frame").src = urls.shift();
+}
+
+SimpleTest.waitForExplicitFinish();
+runTest();
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_websocket_sharedWorker.html b/dom/websocket/tests/test_websocket_sharedWorker.html
new file mode 100644
index 0000000000..b79b0a6ced
--- /dev/null
+++ b/dom/websocket/tests/test_websocket_sharedWorker.html
@@ -0,0 +1,30 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for bug 1090183</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<script class="testbody" type="text/javascript">
+
+var sw = new SharedWorker('websocket_sharedWorker.js');
+sw.port.onmessage = function(event) {
+  if (event.data.type == 'finish') {
+    SimpleTest.finish();
+  } else if (event.data.type == 'status') {
+    ok(event.data.status, event.data.msg);
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket1.html b/dom/websocket/tests/test_worker_websocket1.html
new file mode 100644
index 0000000000..71414fbe42
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket1.html
@@ -0,0 +1,46 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<pre id="feedback"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_worker1.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker, "event.target should be a worker!");
+
+    if (event.data.type == 'finish') {
+      info("All done!");
+      SimpleTest.finish();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    } else if (event.data.type == 'feedback') {
+      info(event.data.msg);
+      document.getElementById('feedback').innerHTML += event.data.msg + "\n";
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    info("error!");
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  worker.postMessage('foobar');
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket2.html b/dom/websocket/tests/test_worker_websocket2.html
new file mode 100644
index 0000000000..d9e16281b9
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket2.html
@@ -0,0 +1,46 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<pre id="feedback"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_worker2.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker, "event.target should be a worker!");
+
+    if (event.data.type == 'finish') {
+      info("All done!");
+      SimpleTest.finish();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    } else if (event.data.type == 'feedback') {
+      info(event.data.msg);
+      document.getElementById('feedback').innerHTML += event.data.msg + "\n";
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    info("error!");
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  worker.postMessage('foobar');
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket3.html b/dom/websocket/tests/test_worker_websocket3.html
new file mode 100644
index 0000000000..4387192c42
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket3.html
@@ -0,0 +1,46 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<pre id="feedback"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_worker3.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker, "event.target should be a worker!");
+
+    if (event.data.type == 'finish') {
+      info("All done!");
+      SimpleTest.finish();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    } else if (event.data.type == 'feedback') {
+      info(event.data.msg);
+      document.getElementById('feedback').innerHTML += event.data.msg + "\n";
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    info("error!");
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  worker.postMessage('foobar');
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket4.html b/dom/websocket/tests/test_worker_websocket4.html
new file mode 100644
index 0000000000..5f4c390574
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket4.html
@@ -0,0 +1,46 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<pre id="feedback"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_worker4.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker, "event.target should be a worker!");
+
+    if (event.data.type == 'finish') {
+      info("All done!");
+      SimpleTest.finish();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    } else if (event.data.type == 'feedback') {
+      info(event.data.msg);
+      document.getElementById('feedback').innerHTML += event.data.msg + "\n";
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    info("error!");
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  worker.postMessage('foobar');
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket5.html b/dom/websocket/tests/test_worker_websocket5.html
new file mode 100644
index 0000000000..0b3450b7b6
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket5.html
@@ -0,0 +1,46 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<pre id="feedback"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_worker5.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker, "event.target should be a worker!");
+
+    if (event.data.type == 'finish') {
+      info("All done!");
+      SimpleTest.finish();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    } else if (event.data.type == 'feedback') {
+      info(event.data.msg);
+      document.getElementById('feedback').innerHTML += event.data.msg + "\n";
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    info("error!");
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  worker.postMessage('foobar');
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket_basic.html b/dom/websocket/tests/test_worker_websocket_basic.html
new file mode 100644
index 0000000000..39ff1647e7
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket_basic.html
@@ -0,0 +1,57 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_basic_worker.js");
+
+  worker.onmessage = function(event) {
+    is(event.target, worker);
+
+    if (event.data.type == 'finish') {
+      runTest();
+    } else if (event.data.type == 'status') {
+      ok(event.data.status, event.data.msg);
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  var tests = [
+    function() { worker.postMessage(0); },
+    function() { worker.postMessage(1); }
+  ];
+
+  function runTest() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var test = tests.shift();
+    test();
+  }
+
+  runTest();
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket_https.html b/dom/websocket/tests/test_worker_websocket_https.html
new file mode 100644
index 0000000000..9283b9bd09
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket_https.html
@@ -0,0 +1,30 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test that creating insecure websockets from https workers is not possible</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" language="javascript">
+
+  onmessage = function(event) {
+    is(event.data, "not created", "WebSocket object must not be created");
+    SimpleTest.finish();
+  };
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+<iframe src="https://example.com/tests/dom/websocket/tests/websocket_worker_https.html"></iframe>
+</body>
+</html>
diff --git a/dom/websocket/tests/test_worker_websocket_loadgroup.html b/dom/websocket/tests/test_worker_websocket_loadgroup.html
new file mode 100644
index 0000000000..d02b8f149c
--- /dev/null
+++ b/dom/websocket/tests/test_worker_websocket_loadgroup.html
@@ -0,0 +1,61 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for WebSocket object in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script class="testbody" type="text/javascript">
+
+  var worker = new Worker("websocket_loadgroup_worker.js");
+
+  var stopped = false;
+  worker.onmessage = function(e) {
+    if (e.data == 'opened') {
+      stopped = true;
+      window.stop();
+    } else if (e.data == 'closed') {
+      ok(stopped, "Good!");
+      stopped = false;
+      runTest();
+    } else {
+      ok(false, "An error has been received");
+    }
+  };
+
+  worker.onerror = function(event) {
+    is(event.target, worker);
+    ok(false, "Worker had an error: " + event.data);
+    SimpleTest.finish();
+  };
+
+  var tests = [
+    function() { worker.postMessage(0); },
+    function() { worker.postMessage(1); }
+  ];
+
+  function runTest() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var test = tests.shift();
+    test();
+  }
+
+  runTest();
+  SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/websocket/tests/websocket_basic_worker.js b/dom/websocket/tests/websocket_basic_worker.js
new file mode 100644
index 0000000000..089fe3edc4
--- /dev/null
+++ b/dom/websocket/tests/websocket_basic_worker.js
@@ -0,0 +1,48 @@
+onmessage = function (event) {
+  if (event.data != 0) {
+    var worker = new Worker("websocket_basic_worker.js");
+    worker.onmessage = function (e) {
+      postMessage(e.data);
+    };
+
+    worker.postMessage(event.data - 1);
+    return;
+  }
+
+  status = false;
+  try {
+    if (WebSocket instanceof Object) {
+      status = true;
+    }
+  } catch (e) {}
+
+  postMessage({
+    type: "status",
+    status,
+    msg: "WebSocket object:" + WebSocket,
+  });
+
+  var ws = new WebSocket(
+    "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello"
+  );
+  ws.onopen = function (e) {
+    postMessage({ type: "status", status: true, msg: "OnOpen called" });
+    ws.send("data");
+  };
+
+  ws.onclose = function (e) {};
+
+  ws.onerror = function (e) {
+    postMessage({ type: "status", status: false, msg: "onerror called!" });
+  };
+
+  ws.onmessage = function (e) {
+    postMessage({
+      type: "status",
+      status: e.data == "Hello world!",
+      msg: "Wrong data",
+    });
+    ws.close();
+    postMessage({ type: "finish" });
+  };
+};
diff --git a/dom/websocket/tests/websocket_helpers.js b/dom/websocket/tests/websocket_helpers.js
new file mode 100644
index 0000000000..6b988b2fa4
--- /dev/null
+++ b/dom/websocket/tests/websocket_helpers.js
@@ -0,0 +1,69 @@
+var current_test = 0;
+
+function shouldNotOpen(e) {
+  var ws = e.target;
+  ok(false, "onopen shouldn't be called on test " + ws._testNumber + "!");
+}
+
+function shouldCloseCleanly(e) {
+  var ws = e.target;
+  ok(
+    e.wasClean,
+    "the ws connection in test " + ws._testNumber + " should be closed cleanly"
+  );
+}
+
+function shouldCloseNotCleanly(e) {
+  var ws = e.target;
+  ok(
+    !e.wasClean,
+    "the ws connection in test " +
+      ws._testNumber +
+      " shouldn't be closed cleanly"
+  );
+}
+
+function ignoreError(e) {}
+
+function CreateTestWS(ws_location, ws_protocol) {
+  var ws;
+
+  if (ws_protocol == undefined) {
+    ws = new WebSocket(ws_location);
+  } else {
+    ws = new WebSocket(ws_location, ws_protocol);
+  }
+
+  ws._testNumber = current_test;
+  ok(true, "Created websocket for test " + ws._testNumber + "\n");
+
+  ws.onerror = function (e) {
+    ok(false, "onerror called on test " + e.target._testNumber + "!");
+  };
+
+  return ws;
+}
+
+function forcegc() {
+  SpecialPowers.forceGC();
+  SpecialPowers.gc();
+}
+
+function feedback() {
+  $("feedback").innerHTML =
+    "executing test: " + (current_test + 1) + " of " + tests.length + " tests.";
+}
+
+function finish() {
+  SimpleTest.finish();
+}
+
+function doTest() {
+  if (current_test >= tests.length) {
+    finish();
+    return;
+  }
+
+  feedback();
+  tests[current_test++]().then(doTest);
+}
diff --git a/dom/websocket/tests/websocket_https_worker.js b/dom/websocket/tests/websocket_https_worker.js
new file mode 100644
index 0000000000..e07b0dbec5
--- /dev/null
+++ b/dom/websocket/tests/websocket_https_worker.js
@@ -0,0 +1,11 @@
+onmessage = function () {
+  var wsCreated = true;
+  try {
+    new WebSocket(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello"
+    );
+  } catch (e) {
+    wsCreated = false;
+  }
+  postMessage(wsCreated ? "created" : "not created");
+};
diff --git a/dom/websocket/tests/websocket_hybi/file_binary-frames_wsh.py b/dom/websocket/tests/websocket_hybi/file_binary-frames_wsh.py
new file mode 100644
index 0000000000..16ace4d3a6
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/file_binary-frames_wsh.py
@@ -0,0 +1,19 @@
+import six
+from mod_pywebsocket import common, stream
+
+
+def web_socket_do_extra_handshake(request):
+    pass
+
+
+def web_socket_transfer_data(request):
+    messages_to_send = ["Hello, world!", "", all_distinct_bytes()]
+    for message in messages_to_send:
+        message = six.b(message)
+        # FIXME: Should use better API to send binary messages when pywebsocket supports it.
+        header = stream.create_header(common.OPCODE_BINARY, len(message), 1, 0, 0, 0, 0)
+        request.connection.write(header + message)
+
+
+def all_distinct_bytes():
+    return "".join([chr(i) for i in range(256)])
diff --git a/dom/websocket/tests/websocket_hybi/file_check-binary-messages_wsh.py b/dom/websocket/tests/websocket_hybi/file_check-binary-messages_wsh.py
new file mode 100644
index 0000000000..d72ec1f462
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/file_check-binary-messages_wsh.py
@@ -0,0 +1,27 @@
+import six
+from mod_pywebsocket import msgutil
+
+
+def web_socket_do_extra_handshake(request):
+    pass  # Always accept.
+
+
+def web_socket_transfer_data(request):
+    expected_messages = ["Hello, world!", "", all_distinct_bytes()]
+
+    for test_number, expected_message in enumerate(expected_messages):
+        expected_message = six.b(expected_message)
+        message = msgutil.receive_message(request)
+        if message == expected_message:
+            msgutil.send_message(request, "PASS: Message #{:d}.".format(test_number))
+        else:
+            msgutil.send_message(
+                request,
+                "FAIL: Message #{:d}: Received unexpected message: {!r}".format(
+                    test_number, message
+                ),
+            )
+
+
+def all_distinct_bytes():
+    return "".join([chr(i) for i in range(256)])
diff --git a/dom/websocket/tests/websocket_hybi/mochitest.ini b/dom/websocket/tests/websocket_hybi/mochitest.ini
new file mode 100644
index 0000000000..dbba7ba175
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/mochitest.ini
@@ -0,0 +1,15 @@
+[DEFAULT]
+skip-if =
+  http3
+support-files =
+  file_binary-frames_wsh.py
+  file_check-binary-messages_wsh.py
+
+[test_receive-arraybuffer.html]
+skip-if = toolkit == 'android'
+[test_receive-blob.html]
+skip-if = toolkit == 'android'
+[test_send-arraybuffer.html]
+skip-if = toolkit == 'android'
+[test_send-blob.html]
+skip-if = toolkit == 'android'
diff --git a/dom/websocket/tests/websocket_hybi/test_receive-arraybuffer.html b/dom/websocket/tests/websocket_hybi/test_receive-arraybuffer.html
new file mode 100644
index 0000000000..6d465b7677
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/test_receive-arraybuffer.html
@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+
+<script class="testbody" type="text/javascript">
+
+function debug(msg) {
+   ok(1, msg);
+}
+
+function createArrayBufferContainingHelloWorld()
+{
+    var hello = "Hello, world!";
+    var array = new Uint8Array(hello.length);
+    for (var i = 0; i < hello.length; ++i)
+        array[i] = hello.charCodeAt(i);
+    return array.buffer;
+}
+
+function createEmptyArrayBuffer()
+{
+    return new ArrayBuffer(0);
+}
+
+function createArrayBufferContainingAllDistinctBytes()
+{
+    var array = new Uint8Array(256);
+    for (var i = 0; i < 256; ++i)
+        array[i] = i;
+    return array.buffer;
+}
+
+var ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/websocket_hybi/file_binary-frames");
+ws.binaryType = "arraybuffer";
+is(ws.binaryType, "arraybuffer", "should be equal to 'arraybuffer'");
+
+var closeEvent;
+var receivedMessages = [];
+var expectedValues = [createArrayBufferContainingHelloWorld(), createEmptyArrayBuffer(), createArrayBufferContainingAllDistinctBytes()];
+
+ws.onmessage = function(event)
+{
+    receivedMessages.push(event.data);
+};
+
+ws.onclose = function(event)
+{
+    closeEvent = event;
+
+    is(receivedMessages.length, expectedValues.length, "lengths not equal");
+    for (var i = 0; i < expectedValues.length; ++i)
+        check(i);
+    SimpleTest.finish();
+};
+
+var responseType;
+
+function check(index)
+{
+    debug("Checking message #" + index + ".");
+    ok(receivedMessages[index] instanceof ArrayBuffer,
+       "Should receive an arraybuffer!");
+    checkArrayBuffer(index, receivedMessages[index], expectedValues[index]);
+}
+
+var actualArray;
+var expectedArray;
+
+function checkArrayBuffer(testIndex, actual, expected)
+{
+    actualArray = new Uint8Array(actual);
+    expectedArray = new Uint8Array(expected);
+    is(actualArray.length, expectedArray.length, "lengths not equal");
+    // Print only the first mismatched byte in order not to flood console.
+    for (var i = 0; i < expectedArray.length; ++i) {
+        if (actualArray[i] != expectedArray[i]) {
+            ok(false, "Value mismatch: actualArray[" + i + "] = " + actualArray[i] + ", expectedArray[" + i + "] = " + expectedArray[i]);
+            return;
+        }
+    }
+    ok(true, "Passed: Message #" + testIndex + ".");
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/websocket_hybi/test_receive-blob.html b/dom/websocket/tests/websocket_hybi/test_receive-blob.html
new file mode 100644
index 0000000000..5589633a7c
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/test_receive-blob.html
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+
+<script class="testbody" type="text/javascript">
+
+function debug(msg) {
+   ok(true, msg);
+}
+
+function createArrayBufferContainingHelloWorld()
+{
+    var hello = "Hello, world!";
+    var array = new Uint8Array(hello.length);
+    for (var i = 0; i < hello.length; ++i)
+        array[i] = hello.charCodeAt(i);
+    return array.buffer;
+}
+
+function createEmptyArrayBuffer()
+{
+    return new ArrayBuffer(0);
+}
+
+function createArrayBufferContainingAllDistinctBytes()
+{
+    var array = new Uint8Array(256);
+    for (var i = 0; i < 256; ++i)
+        array[i] = i;
+    return array.buffer;
+}
+
+var ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/websocket_hybi/file_binary-frames");
+is(ws.binaryType, "blob", "should be 'blob'");
+
+var closeEvent;
+var receivedMessages = [];
+var expectedValues = [createArrayBufferContainingHelloWorld(), createEmptyArrayBuffer(), createArrayBufferContainingAllDistinctBytes()];
+
+ws.onmessage = function(event)
+{
+    receivedMessages.push(event.data);
+};
+
+ws.onclose = function(event)
+{
+    closeEvent = event;
+
+    is(receivedMessages.length, expectedValues.length, "lengths not same");
+    check(0);
+};
+
+var responseType;
+
+function check(index)
+{
+    if (index == expectedValues.length) {
+        SimpleTest.finish();
+        return;
+    }
+
+    debug("Checking message #" + index + ".");
+    ok(receivedMessages[index] instanceof Blob,
+       "We should be receiving a Blob");
+    var reader = new FileReader();
+    reader.readAsArrayBuffer(receivedMessages[index]);
+    reader.onload = function(event)
+    {
+        checkArrayBuffer(index, reader.result, expectedValues[index]);
+        check(index + 1);
+    };
+    reader.onerror = function(event)
+    {
+        ok(false, "Failed to read blob: error code = " + reader.error.code);
+        check(index + 1);
+    };
+}
+
+var actualArray;
+var expectedArray;
+
+function checkArrayBuffer(testIndex, actual, expected)
+{
+    actualArray = new Uint8Array(actual);
+    expectedArray = new Uint8Array(expected);
+    is(actualArray.length, expectedArray.length, "lengths not same");
+    // Print only the first mismatched byte in order not to flood console.
+    for (var i = 0; i < expectedArray.length; ++i) {
+        if (actualArray[i] != expectedArray[i]) {
+            ok(false, "Value mismatch: actualArray[" + i + "] = " + actualArray[i] + ", expectedArray[" + i + "] = " + expectedArray[i]);
+            return;
+        }
+    }
+    ok(true, "Passed: Message #" + testIndex + ".");
+}
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/websocket_hybi/test_send-arraybuffer.html b/dom/websocket/tests/websocket_hybi/test_send-arraybuffer.html
new file mode 100644
index 0000000000..6c71ca5415
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/test_send-arraybuffer.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<p id="display"></p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+
+<script class="testbody" type="text/javascript">
+
+function debug(msg) {
+   ok(1, msg);
+}
+
+function startsWith(target, prefix)
+{
+    return target.indexOf(prefix) === 0;
+}
+
+function createArrayBufferContainingHelloWorld()
+{
+    var hello = "Hello, world!";
+    var array = new Uint8Array(hello.length);
+    for (var i = 0; i < hello.length; ++i)
+        array[i] = hello.charCodeAt(i);
+    return array.buffer;
+}
+
+function createEmptyArrayBuffer()
+{
+    return new ArrayBuffer(0);
+}
+
+function createArrayBufferContainingAllDistinctBytes()
+{
+    var array = new Uint8Array(256);
+    for (var i = 0; i < 256; ++i)
+        array[i] = i;
+    return array.buffer;
+}
+
+var ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/websocket_hybi/file_check-binary-messages");
+var closeEvent;
+
+ws.onopen = function()
+{
+    ok(true, "onopen reached");
+    ws.send(createArrayBufferContainingHelloWorld());
+    ws.send(createEmptyArrayBuffer());
+    ws.send(createArrayBufferContainingAllDistinctBytes());
+};
+
+ws.onmessage = function(event)
+{
+    var message = event.data;
+    if (startsWith(message, "PASS"))
+        ok(true, message);
+    else
+        ok(false, message);
+};
+
+ws.onclose = function(event)
+{
+    ok(event.wasClean, "should have closed cleanly");
+    SimpleTest.finish();
+};
+
+ws.onerror = function(event)
+{
+    ok(false, "onerror should not have been called");
+};
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/websocket_hybi/test_send-blob.html b/dom/websocket/tests/websocket_hybi/test_send-blob.html
new file mode 100644
index 0000000000..6af1e2df03
--- /dev/null
+++ b/dom/websocket/tests/websocket_hybi/test_send-blob.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<p id="display">
+</p>
+<div id="content" style="display: none">
+</div>
+<pre id="test">
+
+<script class="testbody" type="text/javascript">
+
+function startsWith(target, prefix)
+{
+    return target.indexOf(prefix) === 0;
+}
+
+function distinctBytes()
+{
+    var array = new Array();
+    for (var i = 0; i < 256; ++i)
+        array[i] = i;
+    // Concatenates chars into a single binary string
+    return String.fromCharCode.apply(null, array);
+}
+
+var filesToCreate = [
+  {name: "hellofile", data: "Hello, world!"},
+  {name: "emptyfile"},
+  {name: "allchars", data: distinctBytes()},
+];
+
+SpecialPowers.createFiles(filesToCreate, function (files) {
+  var ws = new WebSocket("ws://mochi.test:8888/tests/dom/websocket/tests/websocket_hybi/file_check-binary-messages");
+  var closeEvent;
+
+  ws.onopen = function()
+  {
+      ws.send(files[0]);
+      ws.send(files[1]);
+      ws.send(files[2]);
+  };
+
+  ws.onmessage = function(event)
+  {
+      var message = event.data;
+      if (startsWith(message, "PASS"))
+          ok(true, message);
+      else
+          ok(false, message);
+  };
+
+  ws.onclose = function(event)
+  {
+    ok(event.wasClean, "should have closed cleanly");
+    SimpleTest.finish();
+  };
+},
+function (msg) {
+  ok(false, "Failed to create files: " + msg);
+  SimpleTest.finish();
+});
+
+SimpleTest.waitForExplicitFinish();
+
+</script>
+</body>
+</html>
diff --git a/dom/websocket/tests/websocket_loadgroup_worker.js b/dom/websocket/tests/websocket_loadgroup_worker.js
new file mode 100644
index 0000000000..6de82d1900
--- /dev/null
+++ b/dom/websocket/tests/websocket_loadgroup_worker.js
@@ -0,0 +1,26 @@
+onmessage = function (event) {
+  if (event.data != 0) {
+    var worker = new Worker("websocket_loadgroup_worker.js");
+    worker.onmessage = function (e) {
+      postMessage(e.data);
+    };
+
+    worker.postMessage(event.data - 1);
+    return;
+  }
+
+  var ws = new WebSocket(
+    "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello"
+  );
+  ws.onopen = function (e) {
+    postMessage("opened");
+  };
+
+  ws.onclose = function (e) {
+    postMessage("closed");
+  };
+
+  ws.onerror = function (e) {
+    postMessage("error");
+  };
+};
diff --git a/dom/websocket/tests/websocket_sharedWorker.js b/dom/websocket/tests/websocket_sharedWorker.js
new file mode 100644
index 0000000000..7c832f5c30
--- /dev/null
+++ b/dom/websocket/tests/websocket_sharedWorker.js
@@ -0,0 +1,34 @@
+onconnect = function (evt) {
+  var ws = new WebSocket(
+    "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello"
+  );
+
+  ws.onopen = function (e) {
+    evt.ports[0].postMessage({
+      type: "status",
+      status: true,
+      msg: "OnOpen called",
+    });
+    ws.send("data");
+  };
+
+  ws.onclose = function (e) {};
+
+  ws.onerror = function (e) {
+    evt.ports[0].postMessage({
+      type: "status",
+      status: false,
+      msg: "onerror called!",
+    });
+  };
+
+  ws.onmessage = function (e) {
+    evt.ports[0].postMessage({
+      type: "status",
+      status: e.data == "Hello world!",
+      msg: "Wrong data",
+    });
+    ws.close();
+    evt.ports[0].postMessage({ type: "finish" });
+  };
+};
diff --git a/dom/websocket/tests/websocket_tests.js b/dom/websocket/tests/websocket_tests.js
new file mode 100644
index 0000000000..df6e12b45f
--- /dev/null
+++ b/dom/websocket/tests/websocket_tests.js
@@ -0,0 +1,1483 @@
+// test1: client tries to connect to a http scheme location;
+function test1() {
+  return new Promise(function (resolve, reject) {
+    try {
+      var ws = CreateTestWS(
+        "http://mochi.test:8888/tests/dom/websocket/tests/file_websocket"
+      );
+      ok(false, "test1 failed");
+    } catch (e) {
+      ok(true, "test1 failed");
+    }
+
+    resolve();
+  });
+}
+
+// test2: assure serialization of the connections;
+// this test expects that the serialization list to connect to the proxy
+// is empty.
+function test2() {
+  return new Promise(function (resolve, reject) {
+    var waitTest2Part1 = true;
+    var waitTest2Part2 = true;
+
+    var ws1 = CreateTestWS(
+      "ws://sub2.test2.example.com/tests/dom/websocket/tests/file_websocket",
+      "test-2.1"
+    );
+    var ws2 = CreateTestWS(
+      "ws://sub2.test2.example.com/tests/dom/websocket/tests/file_websocket",
+      "test-2.2"
+    );
+
+    var ws2CanConnect = false;
+
+    function maybeFinished() {
+      if (!waitTest2Part1 && !waitTest2Part2) {
+        resolve();
+      }
+    }
+
+    ws1.onopen = function () {
+      ok(true, "ws1 open in test 2");
+      ws2CanConnect = true;
+      ws1.close();
+    };
+
+    ws1.onclose = function (e) {
+      waitTest2Part1 = false;
+      maybeFinished();
+    };
+
+    ws2.onopen = function () {
+      ok(ws2CanConnect, "shouldn't connect yet in test-2!");
+      ws2.close();
+    };
+
+    ws2.onclose = function (e) {
+      waitTest2Part2 = false;
+      maybeFinished();
+    };
+  });
+}
+
+// test3: client tries to connect to an non-existent ws server;
+function test3() {
+  return new Promise(function (resolve, reject) {
+    var hasError = false;
+    var ws = CreateTestWS("ws://this.websocket.server.probably.does.not.exist");
+
+    ws.onopen = shouldNotOpen;
+
+    ws.onerror = function (e) {
+      hasError = true;
+    };
+
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      ok(hasError, "rcvd onerror event");
+      is(e.code, 1006, "test-3 close code should be 1006 but is:" + e.code);
+      resolve();
+    };
+  });
+}
+
+// test4: client tries to connect using a relative url;
+function test4() {
+  return new Promise(function (resolve, reject) {
+    try {
+      var ws = CreateTestWS("file_websocket");
+      ok(false, "test-4 failed");
+    } catch (e) {
+      ok(true, "test-4 failed");
+    }
+
+    resolve();
+  });
+}
+
+// test5: client uses an invalid protocol value;
+function test5() {
+  return new Promise(function (resolve, reject) {
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        ""
+      );
+      ok(false, "couldn't accept an empty string in the protocol parameter");
+    } catch (e) {
+      ok(true, "couldn't accept an empty string in the protocol parameter");
+    }
+
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "\n"
+      );
+      ok(
+        false,
+        "couldn't accept any not printable ASCII character in the protocol parameter"
+      );
+    } catch (e) {
+      ok(
+        true,
+        "couldn't accept any not printable ASCII character in the protocol parameter"
+      );
+    }
+
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "test 5"
+      );
+      ok(false, "U+0020 not acceptable in protocol parameter");
+    } catch (e) {
+      ok(true, "U+0020 not acceptable in protocol parameter");
+    }
+
+    resolve();
+  });
+}
+
+// test6: counter and encoding check;
+function test6() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-6"
+    );
+    var counter = 1;
+
+    ws.onopen = function () {
+      ws.send(counter);
+    };
+
+    ws.onmessage = function (e) {
+      if (counter == 5) {
+        is(e.data, "あいうえお", "test-6 counter 5 data ok");
+        ws.close();
+      } else {
+        is(parseInt(e.data), counter + 1, "bad counter");
+        counter += 2;
+        ws.send(counter);
+      }
+    };
+
+    ws.onclose = function (e) {
+      shouldCloseCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test7: onmessage event origin property check
+function test7() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://sub2.test2.example.org/tests/dom/websocket/tests/file_websocket",
+      "test-7"
+    );
+    var gotmsg = false;
+
+    ws.onopen = function () {
+      ok(true, "test 7 open");
+    };
+
+    ws.onmessage = function (e) {
+      ok(true, "test 7 message");
+      is(
+        e.origin,
+        "ws://sub2.test2.example.org",
+        "onmessage origin set to ws:// host"
+      );
+      gotmsg = true;
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(gotmsg, "recvd message in test 7 before close");
+      shouldCloseCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test8: client calls close() and the server sends the close frame (with no
+//        code or reason) in acknowledgement;
+function test8() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-8"
+    );
+
+    ws.onopen = function () {
+      is(ws.protocol, "test-8", "test-8 subprotocol selection");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      shouldCloseCleanly(e);
+      // We called close() with no close code: so pywebsocket will also send no
+      // close code, which translates to code 1005
+      is(e.code, 1005, "test-8 close code has wrong value:" + e.code);
+      is(e.reason, "", "test-8 close reason has wrong value:" + e.reason);
+      resolve();
+    };
+  });
+}
+
+// test9: client closes the connection before the ws connection is established;
+function test9() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://test2.example.org/tests/dom/websocket/tests/file_websocket",
+      "test-9"
+    );
+
+    ws._receivedErrorEvent = false;
+
+    ws.onopen = shouldNotOpen;
+
+    ws.onerror = function (e) {
+      ws._receivedErrorEvent = true;
+    };
+
+    ws.onclose = function (e) {
+      ok(ws._receivedErrorEvent, "Didn't received the error event in test 9.");
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+
+    ws.close();
+  });
+}
+
+// test10: client sends a message before the ws connection is established;
+function test10() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://sub1.test1.example.com/tests/dom/websocket/tests/file_websocket",
+      "test-10"
+    );
+
+    ws.onclose = function (e) {
+      shouldCloseCleanly(e);
+      resolve();
+    };
+
+    try {
+      ws.send("client data");
+      ok(false, "Couldn't send data before connecting!");
+    } catch (e) {
+      ok(true, "Couldn't send data before connecting!");
+    }
+
+    ws.onopen = function () {
+      ok(true, "test 10 opened");
+      ws.close();
+    };
+  });
+}
+
+// test11: a simple hello echo;
+function test11() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-11"
+    );
+    is(ws.readyState, 0, "create bad readyState in test-11!");
+
+    ws.onopen = function () {
+      is(ws.readyState, 1, "open bad readyState in test-11!");
+      ws.send("client data");
+    };
+
+    ws.onmessage = function (e) {
+      is(e.data, "server data", "bad received message in test-11!");
+      ws.close(1000, "Have a nice day");
+
+      // this ok() is disabled due to a race condition - it state may have
+      // advanced through 2 (closing) and into 3 (closed) before it is evald
+      // ok(ws.readyState == 2, "onmessage bad readyState in test-11!");
+    };
+
+    ws.onclose = function (e) {
+      is(ws.readyState, 3, "onclose bad readyState in test-11!");
+      shouldCloseCleanly(e);
+      is(e.code, 1000, "test 11 got wrong close code: " + e.code);
+      is(
+        e.reason,
+        "Have a nice day",
+        "test 11 got wrong close reason: " + e.reason
+      );
+      resolve();
+    };
+  });
+}
+
+// test12: client sends a message containing unpaired surrogates
+function test12() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-12"
+    );
+
+    ws.onopen = function () {
+      try {
+        // send an unpaired surrogate
+        ws._gotMessage = false;
+        ws.send("a\ud800b");
+        ok(true, "ok to send an unpaired surrogate");
+      } catch (e) {
+        ok(
+          false,
+          "shouldn't fail any more when sending an unpaired surrogate!"
+        );
+      }
+    };
+
+    ws.onmessage = function (msg) {
+      is(
+        msg.data,
+        "SUCCESS",
+        "Unpaired surrogate in UTF-16 not converted in test-12"
+      );
+      ws._gotMessage = true;
+      // Must support unpaired surrogates in close reason, too
+      ws.close(1000, "a\ud800b");
+    };
+
+    ws.onclose = function (e) {
+      is(ws.readyState, 3, "onclose bad readyState in test-12!");
+      ok(ws._gotMessage, "didn't receive message!");
+      shouldCloseCleanly(e);
+      is(e.code, 1000, "test 12 got wrong close code: " + e.code);
+      is(
+        e.reason,
+        "a\ufffdb",
+        "test 11 didn't get replacement char in close reason: " + e.reason
+      );
+      resolve();
+    };
+  });
+}
+
+// test13: server sends an invalid message;
+function test13() {
+  return new Promise(function (resolve, reject) {
+    // previous versions of this test counted the number of protocol errors
+    // returned, but the protocol stack typically closes down after reporting a
+    // protocol level error - trying to resync is too dangerous
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-13"
+    );
+    ws._timesCalledOnError = 0;
+
+    ws.onerror = function () {
+      ws._timesCalledOnError++;
+    };
+
+    ws.onclose = function (e) {
+      ok(ws._timesCalledOnError > 0, "no error events");
+      resolve();
+    };
+  });
+}
+
+// test14: server sends the close frame, it doesn't close the tcp connection
+//         and it keeps sending normal ws messages;
+function test14() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-14"
+    );
+
+    ws.onmessage = function () {
+      ok(
+        false,
+        "shouldn't received message after the server sent the close frame"
+      );
+    };
+
+    ws.onclose = function (e) {
+      shouldCloseCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test15: server closes the tcp connection, but it doesn't send the close
+//         frame;
+function test15() {
+  return new Promise(function (resolve, reject) {
+    /*
+     * DISABLED: see comments for test-15 case in file_websocket_wsh.py
+     */
+    resolve();
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-15"
+    );
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+
+    // termination of the connection might cause an error event if it happens in OPEN
+    ws.onerror = function () {};
+  });
+}
+
+// test16: client calls close() and tries to send a message;
+function test16() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-16"
+    );
+
+    ws.onopen = function () {
+      ws.close();
+      ok(
+        !ws.send("client data"),
+        "shouldn't send message after calling close()"
+      );
+    };
+
+    ws.onmessage = function () {
+      ok(false, "shouldn't send message after calling close()");
+    };
+
+    ws.onerror = function () {};
+
+    ws.onclose = function () {
+      resolve();
+    };
+  });
+}
+
+// test17: see bug 572975 - all event listeners set
+function test17() {
+  return new Promise(function (resolve, reject) {
+    var status_test17 = "not started";
+
+    var test17func = function () {
+      var local_ws = new WebSocket(
+        "ws://sub1.test2.example.org/tests/dom/websocket/tests/file_websocket",
+        "test-17"
+      );
+      status_test17 = "started";
+
+      local_ws.onopen = function (e) {
+        status_test17 = "opened";
+        e.target.send("client data");
+        forcegc();
+      };
+
+      local_ws.onerror = function () {
+        ok(false, "onerror called on test " + current_test + "!");
+      };
+
+      local_ws.onmessage = function (e) {
+        ok(e.data == "server data", "Bad message in test-17");
+        status_test17 = "got message";
+        forcegc();
+      };
+
+      local_ws.onclose = function (e) {
+        ok(status_test17 == "got message", "Didn't got message in test-17!");
+        shouldCloseCleanly(e);
+        status_test17 = "closed";
+        forcegc();
+        resolve();
+      };
+
+      window._test17 = null;
+      forcegc();
+    };
+
+    window._test17 = test17func;
+    window._test17();
+  });
+}
+
+// The tests that expects that their websockets neither open nor close MUST
+// be in the end of the tests, i.e. HERE, in order to prevent blocking the other
+// tests.
+
+// test18: client tries to connect to an http resource;
+function test18() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_http_resource.txt"
+    );
+    ws.onopen = shouldNotOpen;
+    ws.onerror = ignoreError;
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test19: server closes the tcp connection before establishing the ws
+//         connection;
+function test19() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-19"
+    );
+    ws.onopen = shouldNotOpen;
+    ws.onerror = ignoreError;
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test20: see bug 572975 - only on error and onclose event listeners set
+function test20() {
+  return new Promise(function (resolve, reject) {
+    var test20func = function () {
+      var local_ws = new WebSocket(
+        "ws://sub1.test1.example.org/tests/dom/websocket/tests/file_websocket",
+        "test-20"
+      );
+
+      local_ws.onerror = function () {
+        ok(false, "onerror called on test " + current_test + "!");
+      };
+
+      local_ws.onclose = function (e) {
+        ok(true, "test 20 closed despite gc");
+        resolve();
+      };
+
+      local_ws = null;
+      window._test20 = null;
+      forcegc();
+    };
+
+    window._test20 = test20func;
+    window._test20();
+  });
+}
+
+// test21: see bug 572975 - same as test 17, but delete strong event listeners
+//         when receiving the message event;
+function test21() {
+  return new Promise(function (resolve, reject) {
+    var test21func = function () {
+      var local_ws = new WebSocket(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "test-21"
+      );
+      var received_message = false;
+
+      local_ws.onopen = function (e) {
+        e.target.send("client data");
+        forcegc();
+        e.target.onopen = null;
+        forcegc();
+      };
+
+      local_ws.onerror = function () {
+        ok(false, "onerror called on test " + current_test + "!");
+      };
+
+      local_ws.onmessage = function (e) {
+        is(e.data, "server data", "Bad message in test-21");
+        received_message = true;
+        forcegc();
+        e.target.onmessage = null;
+        forcegc();
+      };
+
+      local_ws.onclose = function (e) {
+        shouldCloseCleanly(e);
+        ok(received_message, "close transitioned through onmessage");
+        resolve();
+      };
+
+      local_ws = null;
+      window._test21 = null;
+      forcegc();
+    };
+
+    window._test21 = test21func;
+    window._test21();
+  });
+}
+
+// test22: server takes too long to establish the ws connection;
+function test22() {
+  return new Promise(function (resolve, reject) {
+    const pref_open = "network.websocket.timeout.open";
+    SpecialPowers.setIntPref(pref_open, 5);
+
+    var ws = CreateTestWS(
+      "ws://sub2.test2.example.org/tests/dom/websocket/tests/file_websocket",
+      "test-22"
+    );
+
+    ws.onopen = shouldNotOpen;
+    ws.onerror = ignoreError;
+
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+
+    SpecialPowers.clearUserPref(pref_open);
+  });
+}
+
+// test23: should detect WebSocket on window object;
+function test23() {
+  return new Promise(function (resolve, reject) {
+    ok("WebSocket" in window, "WebSocket should be available on window object");
+    resolve();
+  });
+}
+
+// test24: server rejects sub-protocol string
+function test24() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-does-not-exist"
+    );
+
+    ws.onopen = shouldNotOpen;
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+
+    ws.onerror = function () {};
+  });
+}
+
+// test25: ctor with valid empty sub-protocol array
+function test25() {
+  return new Promise(function (resolve, reject) {
+    var prots = [];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    // This test errors because the server requires a sub-protocol, but
+    // the test just wants to ensure that the ctor doesn't generate an
+    // exception
+    ws.onerror = ignoreError;
+    ws.onopen = shouldNotOpen;
+
+    ws.onclose = function (e) {
+      is(ws.protocol, "", "test25 subprotocol selection");
+      ok(true, "test 25 protocol array close");
+      resolve();
+    };
+  });
+}
+
+// test26: ctor with invalid sub-protocol array containing 1 empty element
+function test26() {
+  return new Promise(function (resolve, reject) {
+    var prots = [""];
+
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        prots
+      );
+      ok(false, "testing empty element sub protocol array");
+    } catch (e) {
+      ok(true, "testing empty sub element protocol array");
+    }
+
+    resolve();
+  });
+}
+
+// test27: ctor with invalid sub-protocol array containing an empty element in
+//         list
+function test27() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test27", ""];
+
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        prots
+      );
+      ok(false, "testing empty element mixed sub protocol array");
+    } catch (e) {
+      ok(true, "testing empty element mixed sub protocol array");
+    }
+
+    resolve();
+  });
+}
+
+// test28: ctor using valid 1 element sub-protocol array
+function test28() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test28"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 28 protocol array open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      is(ws.protocol, "test28", "test28 subprotocol selection");
+      ok(true, "test 28 protocol array close");
+      resolve();
+    };
+  });
+}
+
+// test29: ctor using all valid 5 element sub-protocol array
+function test29() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test29a", "test29b"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 29 protocol array open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 29 protocol array close");
+      resolve();
+    };
+  });
+}
+
+// test30: ctor using valid 1 element sub-protocol array with element server
+//         will reject
+function test30() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-does-not-exist"];
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = shouldNotOpen;
+
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      resolve();
+    };
+
+    ws.onerror = function () {};
+  });
+}
+
+// test31: ctor using valid 2 element sub-protocol array with 1 element server
+//         will reject and one server will accept
+function test31() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-does-not-exist", "test31"];
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 31 protocol array open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      is(ws.protocol, "test31", "test31 subprotocol selection");
+      ok(true, "test 31 protocol array close");
+      resolve();
+    };
+  });
+}
+
+// test32: ctor using invalid sub-protocol array that contains duplicate items
+function test32() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test32", "test32"];
+
+    try {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        prots
+      );
+      ok(false, "testing duplicated element sub protocol array");
+    } catch (e) {
+      ok(true, "testing duplicated sub element protocol array");
+    }
+
+    resolve();
+  });
+}
+
+// test33: test for sending/receiving custom close code (but no close reason)
+function test33() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test33"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 33 open");
+      ws.close(3131); // pass code but not reason
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 33 close");
+      shouldCloseCleanly(e);
+      is(e.code, 3131, "test 33 got wrong close code: " + e.code);
+      is(e.reason, "", "test 33 got wrong close reason: " + e.reason);
+      resolve();
+    };
+  });
+}
+
+// test34: test for receiving custom close code and reason
+function test34() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-34"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 34 open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 34 close");
+      ok(e.wasClean, "test 34 closed cleanly");
+      is(e.code, 1001, "test 34 custom server code");
+      is(e.reason, "going away now", "test 34 custom server reason");
+      resolve();
+    };
+  });
+}
+
+// test35: test for sending custom close code and reason
+function test35() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-35a"
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 35a open");
+      ws.close(3500, "my code");
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 35a close");
+      ok(e.wasClean, "test 35a closed cleanly");
+      var wsb = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "test-35b"
+      );
+
+      wsb.onopen = function (event) {
+        ok(true, "test 35b open");
+        wsb.close();
+      };
+
+      wsb.onclose = function (event) {
+        ok(true, "test 35b close");
+        ok(event.wasClean, "test 35b closed cleanly");
+        is(event.code, 3501, "test 35 custom server code");
+        is(event.reason, "my code", "test 35 custom server reason");
+        resolve();
+      };
+    };
+  });
+}
+
+// test36: negative test for sending out of range close code
+function test36() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-36"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 36 open");
+
+      try {
+        ws.close(13200);
+        ok(false, "testing custom close code out of range");
+      } catch (ex) {
+        ok(true, "testing custom close code out of range");
+        ws.close(3200);
+      }
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 36 close");
+      ok(e.wasClean, "test 36 closed cleanly");
+      resolve();
+    };
+  });
+}
+
+// test37: negative test for too long of a close reason
+function test37() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-37"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 37 open");
+
+      try {
+        ws.close(
+          3100,
+          "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123"
+        );
+        ok(false, "testing custom close reason out of range");
+      } catch (ex) {
+        ok(true, "testing custom close reason out of range");
+        ws.close(
+          3100,
+          "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012"
+        );
+      }
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 37 close");
+      ok(e.wasClean, "test 37 closed cleanly");
+
+      var wsb = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "test-37b"
+      );
+
+      wsb.onopen = function (event) {
+        // now test that a rejected close code and reason dont persist
+        ok(true, "test 37b open");
+        try {
+          wsb.close(
+            3101,
+            "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123"
+          );
+          ok(false, "testing custom close reason out of range 37b");
+        } catch (ex) {
+          ok(true, "testing custom close reason out of range 37b");
+          wsb.close();
+        }
+      };
+
+      wsb.onclose = function (event) {
+        ok(true, "test 37b close");
+        ok(event.wasClean, "test 37b closed cleanly");
+
+        var wsc = CreateTestWS(
+          "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+          "test-37c"
+        );
+
+        wsc.onopen = function (eventInner) {
+          ok(true, "test 37c open");
+          wsc.close();
+        };
+
+        wsc.onclose = function (eventInner) {
+          isnot(
+            eventInner.code,
+            3101,
+            "test 37c custom server code not present"
+          );
+          is(
+            eventInner.reason,
+            "",
+            "test 37c custom server reason not present"
+          );
+          resolve();
+        };
+      };
+    };
+  });
+}
+
+// test38: ensure extensions attribute is defined
+function test38() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-38"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 38 open");
+      isnot(ws.extensions, undefined, "extensions attribute defined");
+      //  is(ws.extensions, "deflate-stream", "extensions attribute deflate-stream");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 38 close");
+      resolve();
+    };
+  });
+}
+
+// test39: a basic wss:// connectivity test
+function test39() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-39"];
+
+    var ws = CreateTestWS(
+      "wss://example.com/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+    status_test39 = "started";
+
+    ws.onopen = function (e) {
+      status_test39 = "opened";
+      ok(true, "test 39 open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 39 close");
+      is(status_test39, "opened", "test 39 did open");
+      resolve();
+    };
+  });
+}
+
+// test40: negative test for wss:// with no cert
+function test40() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-40"];
+
+    var ws = CreateTestWS(
+      "wss://nocert.example.com/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    status_test40 = "started";
+    ws.onerror = ignoreError;
+
+    ws.onopen = function (e) {
+      status_test40 = "opened";
+      ok(false, "test 40 open");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 40 close");
+      is(status_test40, "started", "test 40 did not open");
+      resolve();
+    };
+  });
+}
+
+// test41: HSTS
+function test41() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://example.com/tests/dom/websocket/tests/file_websocket",
+      "test-41a",
+      1
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 41a open");
+      is(
+        ws.url,
+        "ws://example.com/tests/dom/websocket/tests/file_websocket",
+        "test 41a initial ws should not be redirected"
+      );
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 41a close");
+
+      // Since third-party loads can't set HSTS state, this will not set
+      // HSTS for example.com.
+      var wsb = CreateTestWS(
+        "wss://example.com/tests/dom/websocket/tests/file_websocket",
+        "test-41b",
+        1
+      );
+
+      wsb.onopen = function (event) {
+        ok(true, "test 41b open");
+        wsb.close();
+      };
+
+      wsb.onclose = function (event) {
+        ok(true, "test 41b close");
+
+        // try ws:// again, it should be done over ws:// again
+        var wsc = CreateTestWS(
+          "ws://example.com/tests/dom/websocket/tests/file_websocket",
+          "test-41c"
+        );
+
+        wsc.onopen = function () {
+          ok(true, "test 41c open");
+          is(
+            wsc.url,
+            "ws://example.com/tests/dom/websocket/tests/file_websocket",
+            "test 41c ws should not be redirected by hsts to wss"
+          );
+          wsc.close();
+        };
+
+        wsc.onclose = function () {
+          ok(true, "test 41c close");
+          resolve();
+        };
+      };
+    };
+  });
+}
+
+// test42: non-char utf-8 sequences
+function test42() {
+  return new Promise(function (resolve, reject) {
+    // test some utf-8 non-characters. They should be allowed in the
+    // websockets context. Test via round trip echo.
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-42"
+    );
+    var data = ["U+FFFE \ufffe", "U+FFFF \uffff", "U+10FFFF \udbff\udfff"];
+    var index = 0;
+
+    ws.onopen = function () {
+      ws.send(data[0]);
+      ws.send(data[1]);
+      ws.send(data[2]);
+    };
+
+    ws.onmessage = function (e) {
+      is(
+        e.data,
+        data[index],
+        "bad received message in test-42! index=" + index
+      );
+      index++;
+      if (index == 3) {
+        ws.close();
+      }
+    };
+
+    ws.onclose = function (e) {
+      resolve();
+    };
+  });
+}
+
+// test43: Test setting binaryType attribute
+function test43() {
+  return new Promise(function (resolve, reject) {
+    var prots = ["test-43"];
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      prots
+    );
+
+    ws.onopen = function (e) {
+      ok(true, "test 43 open");
+      // Test binaryType setting
+      ws.binaryType = "arraybuffer";
+      ws.binaryType = "blob";
+      ws.binaryType = ""; // illegal
+      is(ws.binaryType, "blob");
+      ws.binaryType = "ArrayBuffer"; // illegal
+      is(ws.binaryType, "blob");
+      ws.binaryType = "Blob"; // illegal
+      is(ws.binaryType, "blob");
+      ws.binaryType = "mcfoofluu"; // illegal
+      is(ws.binaryType, "blob");
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "test 43 close");
+      resolve();
+    };
+  });
+}
+
+// test44: Test sending/receving binary ArrayBuffer
+function test44() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-44"
+    );
+    is(ws.readyState, 0, "bad readyState in test-44!");
+    ws.binaryType = "arraybuffer";
+
+    ws.onopen = function () {
+      is(ws.readyState, 1, "open bad readyState in test-44!");
+      var buf = new ArrayBuffer(3);
+      // create byte view
+      var view = new Uint8Array(buf);
+      view[0] = 5;
+      view[1] = 0; // null byte
+      view[2] = 7;
+      ws.send(buf);
+    };
+
+    ws.onmessage = function (e) {
+      ok(e.data instanceof ArrayBuffer, "Should receive an arraybuffer!");
+      var view = new Uint8Array(e.data);
+      ok(
+        view.length == 2 && view[0] == 0 && view[1] == 4,
+        "testing Reply arraybuffer"
+      );
+      ws.close();
+    };
+
+    ws.onclose = function (e) {
+      is(ws.readyState, 3, "onclose bad readyState in test-44!");
+      shouldCloseCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test45: Test sending/receving binary Blob
+function test45() {
+  return new Promise(function (resolve, reject) {
+    function test45Real(blobFile) {
+      var ws = CreateTestWS(
+        "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+        "test-45"
+      );
+      is(ws.readyState, 0, "bad readyState in test-45!");
+      // ws.binaryType = "blob";  // Don't need to specify: blob is the default
+
+      ws.onopen = function () {
+        is(ws.readyState, 1, "open bad readyState in test-45!");
+        ws.send(blobFile);
+      };
+
+      var test45blob;
+
+      ws.onmessage = function (e) {
+        test45blob = e.data;
+        ok(test45blob instanceof Blob, "We should be receiving a Blob");
+
+        ws.close();
+      };
+
+      ws.onclose = function (e) {
+        is(ws.readyState, 3, "onclose bad readyState in test-45!");
+        shouldCloseCleanly(e);
+
+        // check blob contents
+        var reader = new FileReader();
+        reader.onload = function (event) {
+          is(
+            reader.result,
+            "flob",
+            "response should be 'flob': got '" + reader.result + "'"
+          );
+        };
+
+        reader.onerror = function (event) {
+          testFailed("Failed to read blob: error code = " + reader.error.code);
+        };
+
+        reader.onloadend = function (event) {
+          resolve();
+        };
+
+        reader.readAsBinaryString(test45blob);
+      };
+    }
+
+    SpecialPowers.createFiles(
+      [{ name: "testBlobFile", data: "flob" }],
+      function (files) {
+        test45Real(files[0]);
+      },
+      function (msg) {
+        testFailed("Failed to create file for test45: " + msg);
+        resolve();
+      }
+    );
+  });
+}
+
+// test46: Test that we don't dispatch incoming msgs once in CLOSING state
+function test46() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-46"
+    );
+    is(ws.readyState, 0, "create bad readyState in test-46!");
+
+    ws.onopen = function () {
+      is(ws.readyState, 1, "open bad readyState in test-46!");
+      ws.close();
+      is(ws.readyState, 2, "close must set readyState to 2 in test-46!");
+    };
+
+    ws.onmessage = function (e) {
+      ok(false, "received message after calling close in test-46!");
+    };
+
+    ws.onclose = function (e) {
+      is(ws.readyState, 3, "onclose bad readyState in test-46!");
+      shouldCloseCleanly(e);
+      resolve();
+    };
+  });
+}
+
+// test47: Make sure onerror/onclose aren't called during close()
+function test47() {
+  return new Promise(function (resolve, reject) {
+    var hasError = false;
+    var ws = CreateTestWS(
+      "ws://another.websocket.server.that.probably.does.not.exist"
+    );
+
+    ws.onopen = shouldNotOpen;
+
+    ws.onerror = function (e) {
+      is(
+        ws.readyState,
+        3,
+        "test-47: readyState should be CLOSED(3) in onerror: got " +
+          ws.readyState
+      );
+      ok(!ws._withinClose, "onerror() called during close()!");
+      hasError = true;
+    };
+
+    ws.onclose = function (e) {
+      shouldCloseNotCleanly(e);
+      ok(hasError, "test-47: should have called onerror before onclose");
+      is(
+        ws.readyState,
+        3,
+        "test-47: readyState should be CLOSED(3) in onclose: got " +
+          ws.readyState
+      );
+      ok(!ws._withinClose, "onclose() called during close()!");
+      is(e.code, 1006, "test-47 close code should be 1006 but is:" + e.code);
+      resolve();
+    };
+
+    // Call close before we're connected: throws error
+    // Make sure we call onerror/onclose asynchronously
+    ws._withinClose = 1;
+    ws.close(3333, "Closed before we were open: error");
+    ws._withinClose = 0;
+    is(
+      ws.readyState,
+      2,
+      "test-47: readyState should be CLOSING(2) after close(): got " +
+        ws.readyState
+    );
+  });
+}
+
+// test48: see bug 1227136 - client calls close() from onopen() and waits until
+// WebSocketChannel::mSocketIn is nulled out on socket thread.
+function test48() {
+  return new Promise(function (resolve, reject) {
+    const pref_close = "network.websocket.timeout.close";
+    SpecialPowers.setIntPref(pref_close, 1);
+
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-48"
+    );
+
+    ws.onopen = function () {
+      ws.close();
+
+      var date = new Date();
+      var curDate = null;
+      do {
+        curDate = new Date();
+      } while (curDate - date < 1500);
+    };
+
+    ws.onclose = function (e) {
+      ok(true, "ws close in test 48");
+      resolve();
+    };
+
+    SpecialPowers.clearUserPref(pref_close);
+  });
+}
+
+function test49() {
+  return new Promise(function (resolve, reject) {
+    var ws = CreateTestWS(
+      "ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket",
+      "test-49"
+    );
+    var gotError = 0;
+    ok(ws.readyState == 0, "create bad readyState in test-49!");
+
+    ws.onopen = function () {
+      ok(false, "Connection must fail in test-49");
+    };
+
+    ws.onerror = function (e) {
+      gotError = 1;
+    };
+
+    ws.onclose = function (e) {
+      ok(gotError, "Should get error in test-49!");
+      resolve();
+    };
+  });
+}
diff --git a/dom/websocket/tests/websocket_worker1.js b/dom/websocket/tests/websocket_worker1.js
new file mode 100644
index 0000000000..26b37b8e48
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker1.js
@@ -0,0 +1,19 @@
+importScripts("websocket_helpers.js");
+importScripts("websocket_tests.js");
+importScripts("websocket_worker_helpers.js");
+
+var tests = [
+  test1, // client tries to connect to a http scheme location;
+  test2, // assure serialization of the connections;
+  test3, // client tries to connect to an non-existent ws server;
+  test4, // client tries to connect using a relative url;
+  test5, // client uses an invalid protocol value;
+  test6, // counter and encoding check;
+  test7, // onmessage event origin property check
+  test8, // client calls close() and the server sends the close frame (with no
+  // code or reason) in acknowledgement;
+  test9, // client closes the connection before the ws connection is established;
+  test10, // client sends a message before the ws connection is established;
+];
+
+doTest();
diff --git a/dom/websocket/tests/websocket_worker2.js b/dom/websocket/tests/websocket_worker2.js
new file mode 100644
index 0000000000..fbc4591bdb
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker2.js
@@ -0,0 +1,19 @@
+importScripts("websocket_helpers.js");
+importScripts("websocket_tests.js");
+importScripts("websocket_worker_helpers.js");
+
+var tests = [
+  test11, // a simple hello echo;
+  test12, // client sends a message containing unpaired surrogates
+  test13, //server sends an invalid message;
+  test14, // server sends the close frame, it doesn't close the tcp connection
+  // and it keeps sending normal ws messages;
+  test15, // server closes the tcp connection, but it doesn't send the close
+  // frame;
+  test16, // client calls close() and tries to send a message;
+  test18, // client tries to connect to an http resource;
+  test19, // server closes the tcp connection before establishing the ws
+  // connection;
+];
+
+doTest();
diff --git a/dom/websocket/tests/websocket_worker3.js b/dom/websocket/tests/websocket_worker3.js
new file mode 100644
index 0000000000..8fee7f4ca5
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker3.js
@@ -0,0 +1,17 @@
+importScripts("websocket_helpers.js");
+importScripts("websocket_tests.js");
+importScripts("websocket_worker_helpers.js");
+
+var tests = [
+  test24, // server rejects sub-protocol string
+  test25, // ctor with valid empty sub-protocol array
+  test26, // ctor with invalid sub-protocol array containing 1 empty element
+  test27, // ctor with invalid sub-protocol array containing an empty element in
+  // list
+  test28, // ctor using valid 1 element sub-protocol array
+  test29, // ctor using all valid 5 element sub-protocol array
+  test30, // ctor using valid 1 element sub-protocol array with element server
+  // will reject
+];
+
+doTest();
diff --git a/dom/websocket/tests/websocket_worker4.js b/dom/websocket/tests/websocket_worker4.js
new file mode 100644
index 0000000000..3e3408b019
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker4.js
@@ -0,0 +1,19 @@
+importScripts("websocket_helpers.js");
+importScripts("websocket_tests.js");
+importScripts("websocket_worker_helpers.js");
+
+var tests = [
+  test31, // ctor using valid 2 element sub-protocol array with 1 element server
+  // will reject and one server will accept
+  test32, // ctor using invalid sub-protocol array that contains duplicate items
+  test33, // test for sending/receiving custom close code (but no close reason)
+  test34, // test for receiving custom close code and reason
+  test35, // test for sending custom close code and reason
+  test36, // negative test for sending out of range close code
+  test37, // negative test for too long of a close reason
+  test38, // ensure extensions attribute is defined
+  test39, // a basic wss:// connectivity test
+  test40, // negative test for wss:// with no cert
+];
+
+doTest();
diff --git a/dom/websocket/tests/websocket_worker5.js b/dom/websocket/tests/websocket_worker5.js
new file mode 100644
index 0000000000..0ed1bbd486
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker5.js
@@ -0,0 +1,14 @@
+importScripts("websocket_helpers.js");
+importScripts("websocket_tests.js");
+importScripts("websocket_worker_helpers.js");
+
+var tests = [
+  test42, // non-char utf-8 sequences
+  test43, // Test setting binaryType attribute
+  test44, // Test sending/receving binary ArrayBuffer
+  test46, // Test that we don't dispatch incoming msgs once in CLOSING state
+  test47, // Make sure onerror/onclose aren't called during close()
+  test49, // Test that we fail if subprotocol returned from server doesn't match
+];
+
+doTest();
diff --git a/dom/websocket/tests/websocket_worker_helpers.js b/dom/websocket/tests/websocket_worker_helpers.js
new file mode 100644
index 0000000000..e9c55b1009
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker_helpers.js
@@ -0,0 +1,27 @@
+function feedback() {
+  postMessage({
+    type: "feedback",
+    msg:
+      "executing test: " +
+      (current_test + 1) +
+      " of " +
+      tests.length +
+      " tests.",
+  });
+}
+
+function ok(status, msg) {
+  postMessage({ type: "status", status: !!status, msg });
+}
+
+function is(a, b, msg) {
+  ok(a === b, msg);
+}
+
+function isnot(a, b, msg) {
+  ok(a != b, msg);
+}
+
+function finish() {
+  postMessage({ type: "finish" });
+}
diff --git a/dom/websocket/tests/websocket_worker_https.html b/dom/websocket/tests/websocket_worker_https.html
new file mode 100644
index 0000000000..0eb17af65b
--- /dev/null
+++ b/dom/websocket/tests/websocket_worker_https.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<script>
+  var worker = new Worker("https://example.com/tests/dom/websocket/tests/websocket_https_worker.js");
+
+  worker.onmessage = function(event) {
+    parent.postMessage(event.data, "*");
+  };
+
+  worker.onerror = function(event) {
+    parent.postMessage("error", "*");
+  };
+
+  worker.postMessage("start");
+</script>
diff --git a/dom/websocket/tests/window_bug1384658.html b/dom/websocket/tests/window_bug1384658.html
new file mode 100644
index 0000000000..c2d6e16c8d
--- /dev/null
+++ b/dom/websocket/tests/window_bug1384658.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script>
+  onload = function() {
+    if (window.location.search == "") {
+      window.open("window_bug1384658.html?opened", "_top", "");
+    } else {
+      var iframeURL = "http://mochi.test:8888/tests/dom/websocket/tests/file_bug1384658.html";
+      var iframe = document.createElement("iframe");
+      iframe.src = iframeURL;
+      document.body.appendChild(iframe);
+    }
+  };
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/websocket/tests/window_websocket_wss.html b/dom/websocket/tests/window_websocket_wss.html
new file mode 100644
index 0000000000..391ab74e40
--- /dev/null
+++ b/dom/websocket/tests/window_websocket_wss.html
@@ -0,0 +1,65 @@
+<html><body>
+Creating WebSocket
+<iframe id="frame" sandbox="allow-scripts"></iframe>
+<script type="application/javascript">
+
+function cleanup() {
+  window.document.getElementById("frame").removeAttribute("src");
+  window.document.getElementById("frame").remove();
+}
+
+onmessage = function(e) {
+  cleanup();
+  window.opener.postMessage(e.data, '*');
+}
+
+// Mixed content blocker will prevent loading iframes via http, so in that case pass back the error
+window.document.getElementById("frame").onerror = function(e) {
+  cleanup();
+  window.opener.postMessage("Error - iframe not loaded", '*');
+}
+
+// Load one of the iframe variants?
+if (location.search == '?https_iframe_wss') {
+  window.document.getElementById("frame").src = "https://example.com/tests/dom/websocket/tests/iframe_websocket_wss.html";
+} else if (location.search == '?https_iframe_ws') {
+  window.document.getElementById("frame").src = "https://example.com/tests/dom/websocket/tests/iframe_websocket_wss.html?insecure";
+} else if (location.search == '?http_iframe_wss' || location.search == '?http_iframe_ws') {
+  let iFrameUrl = "http://example.com/tests/dom/websocket/tests/iframe_websocket_wss.html";
+  if (location.search == '?http_iframe_ws') {
+    iFrameUrl += "?insecure";
+  }
+  window.document.getElementById("frame").src = iFrameUrl;
+}
+else {
+  try {
+    let socket;
+    if (location.search == '?insecure') {
+      socket = new WebSocket('ws://mochi.test:8888/tests/dom/websocket/tests/file_websocket_hello');
+    }
+    else {
+      socket = new WebSocket('wss://example.com/tests/dom/websocket/tests/file_websocket_hello');
+    }
+    socket.onerror = function(e) {
+      cleanup();
+      window.opener.postMessage("WS onerror", "*");
+    };
+    socket.onopen = function(event) {
+      socket.close();
+      cleanup();
+      window.opener.postMessage("WS onopen", "*");
+    };
+  }
+  catch(e) {
+    if (e.name == 'SecurityError') {
+      cleanup();
+      window.opener.postMessage("SecurityError", "*");
+    } else {
+      cleanup();
+      window.opener.postMessage("Test Throws", "*");
+    }
+  }
+}
+
+</script>
+</body></html>