summaryrefslogtreecommitdiffstats
path: root/dom/url
diff options
context:
space:
mode:
Diffstat (limited to 'dom/url')
-rw-r--r--dom/url/URL.cpp1832
-rw-r--r--dom/url/URL.h183
-rw-r--r--dom/url/URLSearchParams.cpp549
-rw-r--r--dom/url/URLSearchParams.h223
-rw-r--r--dom/url/moz.build27
-rw-r--r--dom/url/tests/browser.ini5
-rw-r--r--dom/url/tests/browser_download_after_revoke.js53
-rw-r--r--dom/url/tests/chrome.ini12
-rw-r--r--dom/url/tests/empty.html2
-rw-r--r--dom/url/tests/file_url.jsm22
-rw-r--r--dom/url/tests/file_worker_url.jsm26
-rw-r--r--dom/url/tests/jsm_url_worker.js83
-rw-r--r--dom/url/tests/mochitest.ini21
-rw-r--r--dom/url/tests/test_bloburl_location.html31
-rw-r--r--dom/url/tests/test_bug883784.jsm42
-rw-r--r--dom/url/tests/test_bug883784.xul36
-rw-r--r--dom/url/tests/test_unknown_url_origin.html17
-rw-r--r--dom/url/tests/test_url.html442
-rw-r--r--dom/url/tests/test_url.xul26
-rw-r--r--dom/url/tests/test_urlExceptions.html57
-rw-r--r--dom/url/tests/test_urlSearchParams.html334
-rw-r--r--dom/url/tests/test_urlSearchParams_utf8.html40
-rw-r--r--dom/url/tests/test_url_data.html37
-rw-r--r--dom/url/tests/test_url_empty_port.html53
-rw-r--r--dom/url/tests/test_url_malformedHost.html48
-rw-r--r--dom/url/tests/test_urlutils_stringify.html38
-rw-r--r--dom/url/tests/test_worker_url.html67
-rw-r--r--dom/url/tests/test_worker_url.xul35
-rw-r--r--dom/url/tests/test_worker_urlApi.html45
-rw-r--r--dom/url/tests/test_worker_urlSearchParams.html43
-rw-r--r--dom/url/tests/test_worker_url_exceptions.html44
-rw-r--r--dom/url/tests/urlApi_worker.js272
-rw-r--r--dom/url/tests/urlSearchParams_worker.js162
-rw-r--r--dom/url/tests/url_exceptions_worker.js38
-rw-r--r--dom/url/tests/url_worker.js91
35 files changed, 5036 insertions, 0 deletions
diff --git a/dom/url/URL.cpp b/dom/url/URL.cpp
new file mode 100644
index 000000000..1f15e1151
--- /dev/null
+++ b/dom/url/URL.cpp
@@ -0,0 +1,1832 @@
+/* -*- 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 "URL.h"
+
+#include "DOMMediaStream.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MediaSource.h"
+#include "mozilla/dom/URLBinding.h"
+#include "mozilla/dom/ipc/BlobChild.h"
+#include "mozilla/dom/ipc/nsIRemoteBlob.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "nsContentUtils.h"
+#include "nsEscape.h"
+#include "nsHostObjectProtocolHandler.h"
+#include "nsIIOService.h"
+#include "nsIURIWithQuery.h"
+#include "nsIURL.h"
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "nsServiceManagerUtils.h"
+#include "WorkerPrivate.h"
+#include "WorkerRunnable.h"
+#include "WorkerScope.h"
+
+namespace mozilla {
+namespace dom {
+
+///////////////////////////////////////////////////////////////////////////////
+// URL for main-thread
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+template<typename T>
+void
+CreateObjectURLInternal(const GlobalObject& aGlobal, T aObject,
+ nsAString& aResult, ErrorResult& aRv)
+{
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (NS_WARN_IF(!global)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ nsCOMPtr<nsIPrincipal> principal =
+ nsContentUtils::ObjectPrincipal(aGlobal.Get());
+
+ nsAutoCString url;
+ aRv = nsHostObjectProtocolHandler::AddDataEntry(aObject, principal, url);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ global->RegisterHostObjectURI(url);
+ CopyASCIItoUTF16(url, aResult);
+}
+
+// The URL implementation for the main-thread
+class URLMainThread final : public URL
+{
+public:
+ static already_AddRefed<URLMainThread>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URLMainThread>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URLMainThread>
+ Constructor(nsISupports* aParent, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URLMainThread>
+ Constructor(nsISupports* aParent, const nsAString& aURL, nsIURI* aBase,
+ ErrorResult& aRv);
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ CreateObjectURLInternal(aGlobal, aBlob.Impl(), aResult, aRv);
+ }
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, DOMMediaStream& aStream,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ CreateObjectURLInternal(aGlobal, &aStream, aResult, aRv);
+ }
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, MediaSource& aSource,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv);
+
+ static void
+ RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv);
+
+ static bool
+ IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv);
+
+ URLMainThread(nsISupports* aParent, already_AddRefed<nsIURI> aURI)
+ : URL(aParent)
+ , mURI(aURI)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ virtual void
+ GetHref(nsAString& aHref, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHref(const nsAString& aHref, ErrorResult& aRv) override;
+
+ virtual void
+ GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const override;
+
+ virtual void
+ GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const override;
+
+ virtual void
+ SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) override;
+
+ virtual void
+ GetUsername(nsAString& aUsername, ErrorResult& aRv) const override;
+
+ virtual void
+ SetUsername(const nsAString& aUsername, ErrorResult& aRv) override;
+
+ virtual void
+ GetPassword(nsAString& aPassword, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPassword(const nsAString& aPassword, ErrorResult& aRv) override;
+
+ virtual void
+ GetHost(nsAString& aHost, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHost(const nsAString& aHost, ErrorResult& aRv) override;
+
+ virtual void
+ GetHostname(nsAString& aHostname, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHostname(const nsAString& aHostname, ErrorResult& aRv) override;
+
+ virtual void
+ GetPort(nsAString& aPort, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPort(const nsAString& aPort, ErrorResult& aRv) override;
+
+ virtual void
+ GetPathname(nsAString& aPathname, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPathname(const nsAString& aPathname, ErrorResult& aRv) override;
+
+ virtual void
+ GetSearch(nsAString& aSearch, ErrorResult& aRv) const override;
+
+ virtual void
+ GetHash(nsAString& aHost, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHash(const nsAString& aHash, ErrorResult& aRv) override;
+
+ virtual void UpdateURLSearchParams() override;
+
+ virtual void
+ SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) override;
+
+ nsIURI*
+ GetURI() const
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ return mURI;
+ }
+
+private:
+ ~URLMainThread()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ nsCOMPtr<nsIURI> mURI;
+};
+
+/* static */ already_AddRefed<URLMainThread>
+URLMainThread::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ URLMainThread& base = static_cast<URLMainThread&>(aBase);
+ return Constructor(aGlobal.GetAsSupports(), aURL, base.GetURI(), aRv);
+}
+
+/* static */ already_AddRefed<URLMainThread>
+URLMainThread::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv)
+{
+ if (aBase.WasPassed()) {
+ return Constructor(aGlobal.GetAsSupports(), aURL, aBase.Value(), aRv);
+ }
+
+ return Constructor(aGlobal.GetAsSupports(), aURL, nullptr, aRv);
+}
+
+/* static */ already_AddRefed<URLMainThread>
+URLMainThread::Constructor(nsISupports* aParent, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsCOMPtr<nsIURI> baseUri;
+ nsresult rv = NS_NewURI(getter_AddRefs(baseUri), aBase, nullptr, nullptr,
+ nsContentUtils::GetIOService());
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.ThrowTypeError<MSG_INVALID_URL>(aBase);
+ return nullptr;
+ }
+
+ return Constructor(aParent, aURL, baseUri, aRv);
+}
+
+/* static */ already_AddRefed<URLMainThread>
+URLMainThread::Constructor(nsISupports* aParent, const nsAString& aURL,
+ nsIURI* aBase, ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = NS_NewURI(getter_AddRefs(uri), aURL, nullptr, aBase,
+ nsContentUtils::GetIOService());
+ if (NS_FAILED(rv)) {
+ // No need to warn in this case. It's common to use the URL constructor
+ // to determine if a URL is valid and an exception will be propagated.
+ aRv.ThrowTypeError<MSG_INVALID_URL>(aURL);
+ return nullptr;
+ }
+
+ RefPtr<URLMainThread> url = new URLMainThread(aParent, uri.forget());
+ return url.forget();
+}
+
+/* static */ void
+URLMainThread::CreateObjectURL(const GlobalObject& aGlobal,
+ MediaSource& aSource,
+ const objectURLOptions& aOptions,
+ nsAString& aResult, ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsCOMPtr<nsIPrincipal> principal =
+ nsContentUtils::ObjectPrincipal(aGlobal.Get());
+
+ nsAutoCString url;
+ aRv = nsHostObjectProtocolHandler::AddDataEntry(&aSource, principal, url);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ nsCOMPtr<nsIRunnable> revocation = NS_NewRunnableFunction(
+ [url] {
+ nsHostObjectProtocolHandler::RemoveDataEntry(url);
+ });
+
+ nsContentUtils::RunInStableState(revocation.forget());
+
+ CopyASCIItoUTF16(url, aResult);
+}
+
+/* static */ void
+URLMainThread::RevokeObjectURL(const GlobalObject& aGlobal,
+ const nsAString& aURL, ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ nsIPrincipal* principal = nsContentUtils::ObjectPrincipal(aGlobal.Get());
+
+ NS_LossyConvertUTF16toASCII asciiurl(aURL);
+
+ nsIPrincipal* urlPrincipal =
+ nsHostObjectProtocolHandler::GetDataEntryPrincipal(asciiurl);
+
+ if (urlPrincipal && principal->Subsumes(urlPrincipal)) {
+ global->UnregisterHostObjectURI(asciiurl);
+ nsHostObjectProtocolHandler::RemoveDataEntry(asciiurl);
+ }
+}
+
+/* static */ bool
+URLMainThread::IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ NS_LossyConvertUTF16toASCII asciiurl(aURL);
+ return nsHostObjectProtocolHandler::HasDataEntry(asciiurl);
+}
+
+void
+URLMainThread::GetHref(nsAString& aHref, ErrorResult& aRv) const
+{
+ aHref.Truncate();
+
+ nsAutoCString href;
+ nsresult rv = mURI->GetSpec(href);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(href, aHref);
+ }
+}
+
+void
+URLMainThread::SetHref(const nsAString& aHref, ErrorResult& aRv)
+{
+ NS_ConvertUTF16toUTF8 href(aHref);
+
+ nsresult rv;
+ nsCOMPtr<nsIIOService> ioService(do_GetService(NS_IOSERVICE_CONTRACTID, &rv));
+ if (NS_FAILED(rv)) {
+ aRv.Throw(rv);
+ return;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ rv = ioService->NewURI(href, nullptr, nullptr, getter_AddRefs(uri));
+ if (NS_FAILED(rv)) {
+ aRv.ThrowTypeError<MSG_INVALID_URL>(aHref);
+ return;
+ }
+
+ mURI = uri;
+ UpdateURLSearchParams();
+}
+
+void
+URLMainThread::GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const
+{
+ nsContentUtils::GetUTFOrigin(mURI, aOrigin);
+}
+
+void
+URLMainThread::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const
+{
+ nsAutoCString protocol;
+ if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {
+ aProtocol.Truncate();
+ }
+
+ CopyASCIItoUTF16(protocol, aProtocol);
+ aProtocol.Append(char16_t(':'));
+}
+
+void
+URLMainThread::SetProtocol(const nsAString& aProtocol, ErrorResult& aRv)
+{
+ nsAString::const_iterator start, end;
+ aProtocol.BeginReading(start);
+ aProtocol.EndReading(end);
+ nsAString::const_iterator iter(start);
+
+ FindCharInReadable(':', iter, end);
+
+ // Changing the protocol of a URL, changes the "nature" of the URI
+ // implementation. In order to do this properly, we have to serialize the
+ // existing URL and reparse it in a new object.
+ nsCOMPtr<nsIURI> clone;
+ nsresult rv = mURI->Clone(getter_AddRefs(clone));
+ if (NS_WARN_IF(NS_FAILED(rv)) || !clone) {
+ return;
+ }
+
+ rv = clone->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ nsAutoCString href;
+ rv = clone->GetSpec(href);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ rv = NS_NewURI(getter_AddRefs(uri), href);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ mURI = uri;
+}
+
+#define URL_GETTER( value, func ) \
+ value.Truncate(); \
+ nsAutoCString tmp; \
+ nsresult rv = mURI->func(tmp); \
+ if (NS_SUCCEEDED(rv)) { \
+ CopyUTF8toUTF16(tmp, value); \
+ }
+
+void
+URLMainThread::GetUsername(nsAString& aUsername, ErrorResult& aRv) const
+{
+ URL_GETTER(aUsername, GetUsername);
+}
+
+void
+URLMainThread::SetUsername(const nsAString& aUsername, ErrorResult& aRv)
+{
+ mURI->SetUsername(NS_ConvertUTF16toUTF8(aUsername));
+}
+
+void
+URLMainThread::GetPassword(nsAString& aPassword, ErrorResult& aRv) const
+{
+ URL_GETTER(aPassword, GetPassword);
+}
+
+void
+URLMainThread::SetPassword(const nsAString& aPassword, ErrorResult& aRv)
+{
+ mURI->SetPassword(NS_ConvertUTF16toUTF8(aPassword));
+}
+
+void
+URLMainThread::GetHost(nsAString& aHost, ErrorResult& aRv) const
+{
+ URL_GETTER(aHost, GetHostPort);
+}
+
+void
+URLMainThread::SetHost(const nsAString& aHost, ErrorResult& aRv)
+{
+ mURI->SetHostPort(NS_ConvertUTF16toUTF8(aHost));
+}
+
+void
+URLMainThread::UpdateURLSearchParams()
+{
+ if (!mSearchParams) {
+ return;
+ }
+
+ nsAutoCString search;
+ nsCOMPtr<nsIURL> url(do_QueryInterface(mURI));
+ if (url) {
+ nsresult rv = url->GetQuery(search);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ search.Truncate();
+ }
+ }
+
+ mSearchParams->ParseInput(search);
+}
+
+void
+URLMainThread::GetHostname(nsAString& aHostname, ErrorResult& aRv) const
+{
+ aHostname.Truncate();
+ nsContentUtils::GetHostOrIPv6WithBrackets(mURI, aHostname);
+}
+
+void
+URLMainThread::SetHostname(const nsAString& aHostname, ErrorResult& aRv)
+{
+ // nsStandardURL returns NS_ERROR_UNEXPECTED for an empty hostname
+ // The return code is silently ignored
+ mURI->SetHost(NS_ConvertUTF16toUTF8(aHostname));
+}
+
+void
+URLMainThread::GetPort(nsAString& aPort, ErrorResult& aRv) const
+{
+ aPort.Truncate();
+
+ int32_t port;
+ nsresult rv = mURI->GetPort(&port);
+ if (NS_SUCCEEDED(rv) && port != -1) {
+ nsAutoString portStr;
+ portStr.AppendInt(port, 10);
+ aPort.Assign(portStr);
+ }
+}
+
+void
+URLMainThread::SetPort(const nsAString& aPort, ErrorResult& aRv)
+{
+ nsresult rv;
+ nsAutoString portStr(aPort);
+ int32_t port = -1;
+
+ // nsIURI uses -1 as default value.
+ if (!portStr.IsEmpty()) {
+ port = portStr.ToInteger(&rv);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ }
+
+ mURI->SetPort(port);
+}
+
+void
+URLMainThread::GetPathname(nsAString& aPathname, ErrorResult& aRv) const
+{
+ aPathname.Truncate();
+
+ // Do not throw! Not having a valid URI or URL should result in an empty
+ // string.
+
+ nsCOMPtr<nsIURIWithQuery> url(do_QueryInterface(mURI));
+ if (url) {
+ nsAutoCString file;
+ nsresult rv = url->GetFilePath(file);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(file, aPathname);
+ }
+
+ return;
+ }
+
+ nsAutoCString path;
+ nsresult rv = mURI->GetPath(path);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(path, aPathname);
+ }
+}
+
+void
+URLMainThread::SetPathname(const nsAString& aPathname, ErrorResult& aRv)
+{
+ // Do not throw!
+
+ nsCOMPtr<nsIURIWithQuery> url(do_QueryInterface(mURI));
+ if (url) {
+ url->SetFilePath(NS_ConvertUTF16toUTF8(aPathname));
+ return;
+ }
+}
+
+void
+URLMainThread::GetSearch(nsAString& aSearch, ErrorResult& aRv) const
+{
+ aSearch.Truncate();
+
+ // Do not throw! Not having a valid URI or URL should result in an empty
+ // string.
+
+ nsAutoCString search;
+ nsresult rv;
+
+ nsCOMPtr<nsIURIWithQuery> url(do_QueryInterface(mURI));
+ if (url) {
+ rv = url->GetQuery(search);
+ if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
+ CopyUTF8toUTF16(NS_LITERAL_CSTRING("?") + search, aSearch);
+ }
+ return;
+ }
+}
+
+void
+URLMainThread::GetHash(nsAString& aHash, ErrorResult& aRv) const
+{
+ aHash.Truncate();
+
+ nsAutoCString ref;
+ nsresult rv = mURI->GetRef(ref);
+ if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
+ aHash.Assign(char16_t('#'));
+ if (nsContentUtils::GettersDecodeURLHash()) {
+ NS_UnescapeURL(ref); // XXX may result in random non-ASCII bytes!
+ }
+ AppendUTF8toUTF16(ref, aHash);
+ }
+}
+
+void
+URLMainThread::SetHash(const nsAString& aHash, ErrorResult& aRv)
+{
+ mURI->SetRef(NS_ConvertUTF16toUTF8(aHash));
+}
+
+void
+URLMainThread::SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv)
+{
+ // Ignore failures to be compatible with NS4.
+
+ nsCOMPtr<nsIURIWithQuery> uriWithQuery(do_QueryInterface(mURI));
+ if (uriWithQuery) {
+ uriWithQuery->SetQuery(NS_ConvertUTF16toUTF8(aSearch));
+ return;
+ }
+}
+
+} // anonymous namespace
+
+///////////////////////////////////////////////////////////////////////////////
+// URL for Workers
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+using namespace workers;
+
+// Proxy class to forward all the requests to a URLMainThread object.
+class URLProxy final
+{
+public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(URLProxy)
+
+ explicit URLProxy(already_AddRefed<URLMainThread> aURL)
+ : mURL(aURL)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ URLMainThread* URL()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ return mURL;
+ }
+
+ nsIURI* URI()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ return mURL->GetURI();
+ }
+
+ void ReleaseURI()
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ mURL = nullptr;
+ }
+
+private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~URLProxy()
+ {
+ MOZ_ASSERT(!mURL);
+ }
+
+ RefPtr<URLMainThread> mURL;
+};
+
+// URLWorker implements the URL object in workers.
+class URLWorker final : public URL
+{
+public:
+ static already_AddRefed<URLWorker>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URLWorker>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URLWorker>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv);
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
+ const mozilla::dom::objectURLOptions& aOptions,
+ nsAString& aResult, mozilla::ErrorResult& aRv);
+
+ static void
+ RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aUrl,
+ ErrorResult& aRv);
+
+ static bool
+ IsValidURL(const GlobalObject& aGlobal, const nsAString& aUrl,
+ ErrorResult& aRv);
+
+ URLWorker(WorkerPrivate* aWorkerPrivate, URLProxy* aURLProxy);
+
+ virtual void
+ GetHref(nsAString& aHref, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHref(const nsAString& aHref, ErrorResult& aRv) override;
+
+ virtual void
+ GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const override;
+
+ virtual void
+ GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const override;
+
+ virtual void
+ SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) override;
+
+ virtual void
+ GetUsername(nsAString& aUsername, ErrorResult& aRv) const override;
+
+ virtual void
+ SetUsername(const nsAString& aUsername, ErrorResult& aRv) override;
+
+ virtual void
+ GetPassword(nsAString& aPassword, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPassword(const nsAString& aPassword, ErrorResult& aRv) override;
+
+ virtual void
+ GetHost(nsAString& aHost, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHost(const nsAString& aHost, ErrorResult& aRv) override;
+
+ virtual void
+ GetHostname(nsAString& aHostname, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHostname(const nsAString& aHostname, ErrorResult& aRv) override;
+
+ virtual void
+ GetPort(nsAString& aPort, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPort(const nsAString& aPort, ErrorResult& aRv) override;
+
+ virtual void
+ GetPathname(nsAString& aPathname, ErrorResult& aRv) const override;
+
+ virtual void
+ SetPathname(const nsAString& aPathname, ErrorResult& aRv) override;
+
+ virtual void
+ GetSearch(nsAString& aSearch, ErrorResult& aRv) const override;
+
+ virtual void
+ GetHash(nsAString& aHost, ErrorResult& aRv) const override;
+
+ virtual void
+ SetHash(const nsAString& aHash, ErrorResult& aRv) override;
+
+ virtual void UpdateURLSearchParams() override;
+
+ virtual void
+ SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) override;
+
+ URLProxy*
+ GetURLProxy() const
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ return mURLProxy;
+ }
+
+private:
+ ~URLWorker();
+
+ workers::WorkerPrivate* mWorkerPrivate;
+ RefPtr<URLProxy> mURLProxy;
+};
+
+// This class creates an URL from a DOM Blob on the main thread.
+class CreateURLRunnable : public WorkerMainThreadRunnable
+{
+private:
+ BlobImpl* mBlobImpl;
+ nsAString& mURL;
+
+public:
+ CreateURLRunnable(WorkerPrivate* aWorkerPrivate, BlobImpl* aBlobImpl,
+ const objectURLOptions& aOptions,
+ nsAString& aURL)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ NS_LITERAL_CSTRING("URL :: CreateURL"))
+ , mBlobImpl(aBlobImpl)
+ , mURL(aURL)
+ {
+ MOZ_ASSERT(aBlobImpl);
+
+ DebugOnly<bool> isMutable;
+ MOZ_ASSERT(NS_SUCCEEDED(aBlobImpl->GetMutable(&isMutable)));
+ MOZ_ASSERT(!isMutable);
+ }
+
+ bool
+ MainThreadRun()
+ {
+ using namespace mozilla::ipc;
+
+ AssertIsOnMainThread();
+
+ RefPtr<BlobImpl> newBlobImplHolder;
+
+ if (nsCOMPtr<nsIRemoteBlob> remoteBlob = do_QueryInterface(mBlobImpl)) {
+ if (BlobChild* blobChild = remoteBlob->GetBlobChild()) {
+ if (PBackgroundChild* blobManager = blobChild->GetBackgroundManager()) {
+ PBackgroundChild* backgroundManager =
+ BackgroundChild::GetForCurrentThread();
+ MOZ_ASSERT(backgroundManager);
+
+ if (blobManager != backgroundManager) {
+ // Always make sure we have a blob from an actor we can use on this
+ // thread.
+ blobChild = BlobChild::GetOrCreate(backgroundManager, mBlobImpl);
+ MOZ_ASSERT(blobChild);
+
+ newBlobImplHolder = blobChild->GetBlobImpl();
+ MOZ_ASSERT(newBlobImplHolder);
+
+ mBlobImpl = newBlobImplHolder;
+ }
+ }
+ }
+ }
+
+ DebugOnly<bool> isMutable;
+ MOZ_ASSERT(NS_SUCCEEDED(mBlobImpl->GetMutable(&isMutable)));
+ MOZ_ASSERT(!isMutable);
+
+ nsCOMPtr<nsIPrincipal> principal = mWorkerPrivate->GetPrincipal();
+
+ nsAutoCString url;
+ nsresult rv =
+ nsHostObjectProtocolHandler::AddDataEntry(mBlobImpl, principal, url);
+
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to add data entry for the blob!");
+ SetDOMStringToNull(mURL);
+ return false;
+ }
+
+ if (!mWorkerPrivate->IsSharedWorker() &&
+ !mWorkerPrivate->IsServiceWorker()) {
+ // Walk up to top worker object.
+ WorkerPrivate* wp = mWorkerPrivate;
+ while (WorkerPrivate* parent = wp->GetParent()) {
+ wp = parent;
+ }
+
+ nsCOMPtr<nsIScriptContext> sc = wp->GetScriptContext();
+ // We could not have a ScriptContext in JSM code. In this case, we leak.
+ if (sc) {
+ nsCOMPtr<nsIGlobalObject> global = sc->GetGlobalObject();
+ MOZ_ASSERT(global);
+
+ global->RegisterHostObjectURI(url);
+ }
+ }
+
+ mURL = NS_ConvertUTF8toUTF16(url);
+ return true;
+ }
+};
+
+// This class revokes an URL on the main thread.
+class RevokeURLRunnable : public WorkerMainThreadRunnable
+{
+private:
+ const nsString mURL;
+
+public:
+ RevokeURLRunnable(WorkerPrivate* aWorkerPrivate,
+ const nsAString& aURL)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ NS_LITERAL_CSTRING("URL :: RevokeURL"))
+ , mURL(aURL)
+ {}
+
+ bool
+ MainThreadRun()
+ {
+ AssertIsOnMainThread();
+
+ NS_ConvertUTF16toUTF8 url(mURL);
+
+ nsIPrincipal* urlPrincipal =
+ nsHostObjectProtocolHandler::GetDataEntryPrincipal(url);
+
+ nsCOMPtr<nsIPrincipal> principal = mWorkerPrivate->GetPrincipal();
+
+ bool subsumes;
+ if (urlPrincipal &&
+ NS_SUCCEEDED(principal->Subsumes(urlPrincipal, &subsumes)) &&
+ subsumes) {
+ nsHostObjectProtocolHandler::RemoveDataEntry(url);
+ }
+
+ if (!mWorkerPrivate->IsSharedWorker() &&
+ !mWorkerPrivate->IsServiceWorker()) {
+ // Walk up to top worker object.
+ WorkerPrivate* wp = mWorkerPrivate;
+ while (WorkerPrivate* parent = wp->GetParent()) {
+ wp = parent;
+ }
+
+ nsCOMPtr<nsIScriptContext> sc = wp->GetScriptContext();
+ // We could not have a ScriptContext in JSM code. In this case, we leak.
+ if (sc) {
+ nsCOMPtr<nsIGlobalObject> global = sc->GetGlobalObject();
+ MOZ_ASSERT(global);
+
+ global->UnregisterHostObjectURI(url);
+ }
+ }
+
+ return true;
+ }
+};
+
+// This class checks if an URL is valid on the main thread.
+class IsValidURLRunnable : public WorkerMainThreadRunnable
+{
+private:
+ const nsString mURL;
+ bool mValid;
+
+public:
+ IsValidURLRunnable(WorkerPrivate* aWorkerPrivate,
+ const nsAString& aURL)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ NS_LITERAL_CSTRING("URL :: IsValidURL"))
+ , mURL(aURL)
+ , mValid(false)
+ {}
+
+ bool
+ MainThreadRun()
+ {
+ AssertIsOnMainThread();
+
+ NS_ConvertUTF16toUTF8 url(mURL);
+ mValid = nsHostObjectProtocolHandler::HasDataEntry(url);
+
+ return true;
+ }
+
+ bool
+ IsValidURL() const
+ {
+ return mValid;
+ }
+};
+
+// This class creates a URL object on the main thread.
+class ConstructorRunnable : public WorkerMainThreadRunnable
+{
+private:
+ const nsString mURL;
+
+ nsString mBase; // IsVoid() if we have no base URI string.
+ RefPtr<URLProxy> mBaseProxy;
+
+ RefPtr<URLProxy> mRetval;
+
+public:
+ ConstructorRunnable(WorkerPrivate* aWorkerPrivate,
+ const nsAString& aURL, const Optional<nsAString>& aBase)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ NS_LITERAL_CSTRING("URL :: Constructor"))
+ , mURL(aURL)
+ {
+ if (aBase.WasPassed()) {
+ mBase = aBase.Value();
+ } else {
+ mBase.SetIsVoid(true);
+ }
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ ConstructorRunnable(WorkerPrivate* aWorkerPrivate,
+ const nsAString& aURL, URLProxy* aBaseProxy)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ NS_LITERAL_CSTRING("URL :: Constructor with BaseURL"))
+ , mURL(aURL)
+ , mBaseProxy(aBaseProxy)
+ {
+ mBase.SetIsVoid(true);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ bool
+ MainThreadRun()
+ {
+ AssertIsOnMainThread();
+
+ ErrorResult rv;
+ RefPtr<URLMainThread> url;
+ if (mBaseProxy) {
+ url = URLMainThread::Constructor(nullptr, mURL, mBaseProxy->URI(), rv);
+ } else if (!mBase.IsVoid()) {
+ url = URLMainThread::Constructor(nullptr, mURL, mBase, rv);
+ } else {
+ url = URLMainThread::Constructor(nullptr, mURL, nullptr, rv);
+ }
+
+ if (rv.Failed()) {
+ rv.SuppressException();
+ return true;
+ }
+
+ mRetval = new URLProxy(url.forget());
+ return true;
+ }
+
+ URLProxy*
+ GetURLProxy(ErrorResult& aRv) const
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ if (!mRetval) {
+ aRv.ThrowTypeError<MSG_INVALID_URL>(mURL);
+ }
+
+ return mRetval;
+ }
+};
+
+class TeardownURLRunnable : public Runnable
+{
+public:
+ explicit TeardownURLRunnable(URLProxy* aURLProxy)
+ : mURLProxy(aURLProxy)
+ {
+ }
+
+ NS_IMETHOD Run()
+ {
+ AssertIsOnMainThread();
+
+ mURLProxy->ReleaseURI();
+ mURLProxy = nullptr;
+
+ return NS_OK;
+ }
+
+private:
+ RefPtr<URLProxy> mURLProxy;
+};
+
+// This class is the generic getter for any URL property.
+class GetterRunnable : public WorkerMainThreadRunnable
+{
+public:
+ enum GetterType {
+ GetterHref,
+ GetterOrigin,
+ GetterProtocol,
+ GetterUsername,
+ GetterPassword,
+ GetterHost,
+ GetterHostname,
+ GetterPort,
+ GetterPathname,
+ GetterSearch,
+ GetterHash,
+ };
+
+ GetterRunnable(WorkerPrivate* aWorkerPrivate,
+ GetterType aType, nsAString& aValue,
+ URLProxy* aURLProxy)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ // We can have telemetry keys for each getter when
+ // needed.
+ NS_LITERAL_CSTRING("URL :: getter"))
+ , mValue(aValue)
+ , mType(aType)
+ , mURLProxy(aURLProxy)
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ bool
+ MainThreadRun()
+ {
+ AssertIsOnMainThread();
+ ErrorResult rv;
+
+ switch (mType) {
+ case GetterHref:
+ mURLProxy->URL()->GetHref(mValue, rv);
+ break;
+
+ case GetterOrigin:
+ mURLProxy->URL()->GetOrigin(mValue, rv);
+ break;
+
+ case GetterProtocol:
+ mURLProxy->URL()->GetProtocol(mValue, rv);
+ break;
+
+ case GetterUsername:
+ mURLProxy->URL()->GetUsername(mValue, rv);
+ break;
+
+ case GetterPassword:
+ mURLProxy->URL()->GetPassword(mValue, rv);
+ break;
+
+ case GetterHost:
+ mURLProxy->URL()->GetHost(mValue, rv);
+ break;
+
+ case GetterHostname:
+ mURLProxy->URL()->GetHostname(mValue, rv);
+ break;
+
+ case GetterPort:
+ mURLProxy->URL()->GetPort(mValue, rv);
+ break;
+
+ case GetterPathname:
+ mURLProxy->URL()->GetPathname(mValue, rv);
+ break;
+
+ case GetterSearch:
+ mURLProxy->URL()->GetSearch(mValue, rv);
+ break;
+
+ case GetterHash:
+ mURLProxy->URL()->GetHash(mValue, rv);
+ break;
+ }
+
+ MOZ_ASSERT(!rv.Failed(), "Main-thread getters do not fail.");
+ return true;
+ }
+
+private:
+ nsAString& mValue;
+ GetterType mType;
+ RefPtr<URLProxy> mURLProxy;
+};
+
+// This class is the generic setter for any URL property.
+class SetterRunnable : public WorkerMainThreadRunnable
+{
+public:
+ enum SetterType {
+ SetterHref,
+ SetterProtocol,
+ SetterUsername,
+ SetterPassword,
+ SetterHost,
+ SetterHostname,
+ SetterPort,
+ SetterPathname,
+ SetterSearch,
+ SetterHash,
+ };
+
+ SetterRunnable(WorkerPrivate* aWorkerPrivate,
+ SetterType aType, const nsAString& aValue,
+ URLProxy* aURLProxy)
+ : WorkerMainThreadRunnable(aWorkerPrivate,
+ // We can have telemetry keys for each setter when
+ // needed.
+ NS_LITERAL_CSTRING("URL :: setter"))
+ , mValue(aValue)
+ , mType(aType)
+ , mURLProxy(aURLProxy)
+ , mFailed(false)
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ bool
+ MainThreadRun()
+ {
+ AssertIsOnMainThread();
+ ErrorResult rv;
+
+ switch (mType) {
+ case SetterHref: {
+ mURLProxy->URL()->SetHref(mValue, rv);
+ break;
+ }
+
+ case SetterProtocol:
+ mURLProxy->URL()->SetProtocol(mValue, rv);
+ break;
+
+ case SetterUsername:
+ mURLProxy->URL()->SetUsername(mValue, rv);
+ break;
+
+ case SetterPassword:
+ mURLProxy->URL()->SetPassword(mValue, rv);
+ break;
+
+ case SetterHost:
+ mURLProxy->URL()->SetHost(mValue, rv);
+ break;
+
+ case SetterHostname:
+ mURLProxy->URL()->SetHostname(mValue, rv);
+ break;
+
+ case SetterPort:
+ mURLProxy->URL()->SetPort(mValue, rv);
+ break;
+
+ case SetterPathname:
+ mURLProxy->URL()->SetPathname(mValue, rv);
+ break;
+
+ case SetterSearch:
+ mURLProxy->URL()->SetSearch(mValue, rv);
+ break;
+
+ case SetterHash:
+ mURLProxy->URL()->SetHash(mValue, rv);
+ break;
+ }
+
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ mFailed = true;
+ }
+
+ return true;
+ }
+
+ bool Failed() const
+ {
+ return mFailed;
+ }
+
+private:
+ const nsString mValue;
+ SetterType mType;
+ RefPtr<URLProxy> mURLProxy;
+ bool mFailed;
+};
+
+already_AddRefed<URLWorker>
+FinishConstructor(JSContext* aCx, WorkerPrivate* aPrivate,
+ ConstructorRunnable* aRunnable, ErrorResult& aRv)
+{
+ aRunnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<URLProxy> proxy = aRunnable->GetURLProxy(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<URLWorker> url = new URLWorker(aPrivate, proxy);
+ return url.forget();
+}
+
+/* static */ already_AddRefed<URLWorker>
+URLWorker::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv)
+{
+ MOZ_ASSERT(!NS_IsMainThread());
+
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ URLWorker& base = static_cast<URLWorker&>(aBase);
+ RefPtr<ConstructorRunnable> runnable =
+ new ConstructorRunnable(workerPrivate, aURL, base.GetURLProxy());
+
+ return FinishConstructor(cx, workerPrivate, runnable, aRv);
+}
+
+/* static */ already_AddRefed<URLWorker>
+URLWorker::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv)
+{
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ RefPtr<ConstructorRunnable> runnable =
+ new ConstructorRunnable(workerPrivate, aURL, aBase);
+
+ return FinishConstructor(cx, workerPrivate, runnable, aRv);
+}
+
+/* static */ already_AddRefed<URLWorker>
+URLWorker::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv)
+{
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ Optional<nsAString> base;
+ base = &aBase;
+
+ RefPtr<ConstructorRunnable> runnable =
+ new ConstructorRunnable(workerPrivate, aURL, base);
+
+ return FinishConstructor(cx, workerPrivate, runnable, aRv);
+}
+
+/* static */ void
+URLWorker::CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
+ const mozilla::dom::objectURLOptions& aOptions,
+ nsAString& aResult, mozilla::ErrorResult& aRv)
+{
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ RefPtr<BlobImpl> blobImpl = aBlob.Impl();
+ MOZ_ASSERT(blobImpl);
+
+ aRv = blobImpl->SetMutable(false);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ RefPtr<CreateURLRunnable> runnable =
+ new CreateURLRunnable(workerPrivate, blobImpl, aOptions, aResult);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ if (workerPrivate->IsSharedWorker() || workerPrivate->IsServiceWorker()) {
+ WorkerGlobalScope* scope = workerPrivate->GlobalScope();
+ MOZ_ASSERT(scope);
+
+ scope->RegisterHostObjectURI(NS_ConvertUTF16toUTF8(aResult));
+ }
+}
+
+/* static */ void
+URLWorker::RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aUrl,
+ ErrorResult& aRv)
+{
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ RefPtr<RevokeURLRunnable> runnable =
+ new RevokeURLRunnable(workerPrivate, aUrl);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ if (workerPrivate->IsSharedWorker() || workerPrivate->IsServiceWorker()) {
+ WorkerGlobalScope* scope = workerPrivate->GlobalScope();
+ MOZ_ASSERT(scope);
+
+ scope->UnregisterHostObjectURI(NS_ConvertUTF16toUTF8(aUrl));
+ }
+}
+
+/* static */ bool
+URLWorker::IsValidURL(const GlobalObject& aGlobal, const nsAString& aUrl,
+ ErrorResult& aRv)
+{
+ JSContext* cx = aGlobal.Context();
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(cx);
+
+ RefPtr<IsValidURLRunnable> runnable =
+ new IsValidURLRunnable(workerPrivate, aUrl);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return false;
+ }
+
+ return runnable->IsValidURL();
+}
+
+URLWorker::URLWorker(WorkerPrivate* aWorkerPrivate, URLProxy* aURLProxy)
+ : URL(nullptr)
+ , mWorkerPrivate(aWorkerPrivate)
+ , mURLProxy(aURLProxy)
+{}
+
+URLWorker::~URLWorker()
+{
+ if (mURLProxy) {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ RefPtr<TeardownURLRunnable> runnable =
+ new TeardownURLRunnable(mURLProxy);
+ mURLProxy = nullptr;
+
+ if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
+ NS_ERROR("Failed to dispatch teardown runnable!");
+ }
+ }
+}
+
+void
+URLWorker::GetHref(nsAString& aHref, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHref, aHref,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetHref(const nsAString& aHref, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHref, aHref,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ if (runnable->Failed()) {
+ aRv.ThrowTypeError<MSG_INVALID_URL>(aHref);
+ return;
+ }
+
+ UpdateURLSearchParams();
+}
+
+void
+URLWorker::GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterOrigin, aOrigin,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterProtocol, aProtocol,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetProtocol(const nsAString& aProtocol, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterProtocol,
+ aProtocol, mURLProxy);
+
+ runnable->Dispatch(aRv);
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetUsername(nsAString& aUsername, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterUsername, aUsername,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetUsername(const nsAString& aUsername, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterUsername,
+ aUsername, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetPassword(nsAString& aPassword, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPassword, aPassword,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetPassword(const nsAString& aPassword, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPassword,
+ aPassword, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetHost(nsAString& aHost, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHost, aHost,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetHost(const nsAString& aHost, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHost,
+ aHost, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetHostname(nsAString& aHostname, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHostname, aHostname,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetHostname(const nsAString& aHostname, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHostname,
+ aHostname, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetPort(nsAString& aPort, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPort, aPort,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetPort(const nsAString& aPort, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPort,
+ aPort, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetPathname(nsAString& aPathname, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterPathname,
+ aPathname, mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetPathname(const nsAString& aPathname, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterPathname,
+ aPathname, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::GetSearch(nsAString& aSearch, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterSearch, aSearch,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::GetHash(nsAString& aHash, ErrorResult& aRv) const
+{
+ RefPtr<GetterRunnable> runnable =
+ new GetterRunnable(mWorkerPrivate, GetterRunnable::GetterHash, aHash,
+ mURLProxy);
+
+ runnable->Dispatch(aRv);
+}
+
+void
+URLWorker::SetHash(const nsAString& aHash, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterHash,
+ aHash, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv)
+{
+ RefPtr<SetterRunnable> runnable =
+ new SetterRunnable(mWorkerPrivate, SetterRunnable::SetterSearch,
+ aSearch, mURLProxy);
+
+ runnable->Dispatch(aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return;
+ }
+
+ MOZ_ASSERT(!runnable->Failed());
+}
+
+void
+URLWorker::UpdateURLSearchParams()
+{
+ if (mSearchParams) {
+ nsAutoString search;
+
+ ErrorResult rv;
+ GetSearch(search, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ }
+
+ mSearchParams->ParseInput(NS_ConvertUTF16toUTF8(Substring(search, 1)));
+ }
+}
+
+} // anonymous namespace
+
+///////////////////////////////////////////////////////////////////////////////
+// Base class for URL
+///////////////////////////////////////////////////////////////////////////////
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(URL, mParent, mSearchParams)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(URL)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(URL)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(URL)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+JSObject*
+URL::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return URLBinding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */ already_AddRefed<URL>
+URL::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv)
+{
+ if (NS_IsMainThread()) {
+ return URLMainThread::Constructor(aGlobal, aURL, aBase, aRv);
+ }
+
+ return URLWorker::Constructor(aGlobal, aURL, aBase, aRv);
+}
+
+/* static */ already_AddRefed<URL>
+URL::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv)
+{
+ if (NS_IsMainThread()) {
+ return URLMainThread::Constructor(aGlobal, aURL, aBase, aRv);
+ }
+
+ return URLWorker::Constructor(aGlobal, aURL, aBase, aRv);
+}
+
+/* static */ already_AddRefed<URL>
+URL::WorkerConstructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv)
+{
+ return URLWorker::Constructor(aGlobal, aURL, aBase, aRv);
+}
+
+void
+URL::CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv)
+{
+ if (NS_IsMainThread()) {
+ URLMainThread::CreateObjectURL(aGlobal, aBlob, aOptions, aResult, aRv);
+ } else {
+ URLWorker::CreateObjectURL(aGlobal, aBlob, aOptions, aResult, aRv);
+ }
+}
+
+void
+URL::CreateObjectURL(const GlobalObject& aGlobal, DOMMediaStream& aStream,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ URLMainThread::CreateObjectURL(aGlobal, aStream, aOptions, aResult, aRv);
+}
+
+void
+URL::CreateObjectURL(const GlobalObject& aGlobal, MediaSource& aSource,
+ const objectURLOptions& aOptions,
+ nsAString& aResult,
+ ErrorResult& aRv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ URLMainThread::CreateObjectURL(aGlobal, aSource, aOptions, aResult, aRv);
+}
+
+void
+URL::RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv)
+{
+ if (NS_IsMainThread()) {
+ URLMainThread::RevokeObjectURL(aGlobal, aURL, aRv);
+ } else {
+ URLWorker::RevokeObjectURL(aGlobal, aURL, aRv);
+ }
+}
+
+bool
+URL::IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv)
+{
+ if (NS_IsMainThread()) {
+ return URLMainThread::IsValidURL(aGlobal, aURL, aRv);
+ }
+ return URLWorker::IsValidURL(aGlobal, aURL, aRv);
+}
+
+URLSearchParams*
+URL::SearchParams()
+{
+ CreateSearchParamsIfNeeded();
+ return mSearchParams;
+}
+
+bool IsChromeURI(nsIURI* aURI)
+{
+ bool isChrome = false;
+ if (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)))
+ return isChrome;
+ return false;
+}
+
+void
+URL::CreateSearchParamsIfNeeded()
+{
+ if (!mSearchParams) {
+ mSearchParams = new URLSearchParams(mParent, this);
+ UpdateURLSearchParams();
+ }
+}
+
+void
+URL::SetSearch(const nsAString& aSearch, ErrorResult& aRv)
+{
+ SetSearchInternal(aSearch, aRv);
+ UpdateURLSearchParams();
+}
+
+void
+URL::URLSearchParamsUpdated(URLSearchParams* aSearchParams)
+{
+ MOZ_ASSERT(mSearchParams);
+ MOZ_ASSERT(mSearchParams == aSearchParams);
+
+ nsAutoString search;
+ mSearchParams->Serialize(search);
+
+ ErrorResult rv;
+ SetSearchInternal(search, rv);
+ NS_WARNING_ASSERTION(!rv.Failed(), "SetSearchInternal failed");
+ rv.SuppressException();
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/url/URL.h b/dom/url/URL.h
new file mode 100644
index 000000000..16b4678ba
--- /dev/null
+++ b/dom/url/URL.h
@@ -0,0 +1,183 @@
+/* -*- 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 mozilla_dom_URL_h
+#define mozilla_dom_URL_h
+
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/URLSearchParams.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsString.h"
+#include "nsWrapperCache.h"
+
+class nsISupports;
+class nsIURI;
+
+namespace mozilla {
+
+class ErrorResult;
+class DOMMediaStream;
+
+namespace dom {
+
+class Blob;
+class MediaSource;
+class GlobalObject;
+struct objectURLOptions;
+
+class URL : public URLSearchParamsObserver
+ , public nsWrapperCache
+{
+public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(URL)
+
+ URL(nsISupports* aParent)
+ : mParent(aParent)
+ {}
+
+ // WebIDL methods
+ nsISupports* GetParentObject() const
+ {
+ return mParent;
+ }
+
+ virtual JSObject*
+ WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<URL>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ URL& aBase, ErrorResult& aRv);
+
+ static already_AddRefed<URL>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const Optional<nsAString>& aBase, ErrorResult& aRv);
+
+ // Helper for Fetch API
+ static already_AddRefed<URL>
+ WorkerConstructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const nsAString& aBase, ErrorResult& aRv);
+
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, Blob& aBlob,
+ const objectURLOptions& aOptions,
+ nsAString& aResult, ErrorResult& aRv);
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, DOMMediaStream& aStream,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv);
+
+ static void
+ CreateObjectURL(const GlobalObject& aGlobal, MediaSource& aSource,
+ const objectURLOptions& aOptions, nsAString& aResult,
+ ErrorResult& aRv);
+
+ static void
+ RevokeObjectURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv);
+
+ static bool
+ IsValidURL(const GlobalObject& aGlobal, const nsAString& aURL,
+ ErrorResult& aRv);
+
+ virtual void
+ GetHref(nsAString& aHref, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetHref(const nsAString& aHref, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetOrigin(nsAString& aOrigin, ErrorResult& aRv) const = 0;
+
+ virtual void
+ GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetProtocol(const nsAString& aProtocol, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetUsername(nsAString& aUsername, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetUsername(const nsAString& aUsername, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetPassword(nsAString& aPassword, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetPassword(const nsAString& aPassword, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetHost(nsAString& aHost, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetHost(const nsAString& aHost, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetHostname(nsAString& aHostname, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetHostname(const nsAString& aHostname, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetPort(nsAString& aPort, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetPort(const nsAString& aPort, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetPathname(nsAString& aPathname, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetPathname(const nsAString& aPathname, ErrorResult& aRv) = 0;
+
+ virtual void
+ GetSearch(nsAString& aSearch, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetSearch(const nsAString& aSearch, ErrorResult& aRv);
+
+ URLSearchParams* SearchParams();
+
+ virtual void
+ GetHash(nsAString& aHost, ErrorResult& aRv) const = 0;
+
+ virtual void
+ SetHash(const nsAString& aHash, ErrorResult& aRv) = 0;
+
+ void Stringify(nsAString& aRetval, ErrorResult& aRv) const
+ {
+ GetHref(aRetval, aRv);
+ }
+
+ // URLSearchParamsObserver
+ void
+ URLSearchParamsUpdated(URLSearchParams* aSearchParams) override;
+
+protected:
+ virtual ~URL()
+ {}
+
+ virtual void
+ UpdateURLSearchParams() = 0;
+
+ virtual void
+ SetSearchInternal(const nsAString& aSearch, ErrorResult& aRv) = 0;
+
+ void CreateSearchParamsIfNeeded();
+
+ nsCOMPtr<nsISupports> mParent;
+ RefPtr<URLSearchParams> mSearchParams;
+};
+
+bool IsChromeURI(nsIURI* aURI);
+
+} // namespace dom
+} // namespace mozilla
+
+#endif /* mozilla_dom_URL_h */
diff --git a/dom/url/URLSearchParams.cpp b/dom/url/URLSearchParams.cpp
new file mode 100644
index 000000000..d9492f81c
--- /dev/null
+++ b/dom/url/URLSearchParams.cpp
@@ -0,0 +1,549 @@
+/* -*- 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 "URLSearchParams.h"
+#include "mozilla/dom/URLSearchParamsBinding.h"
+#include "mozilla/dom/EncodingUtils.h"
+#include "nsDOMString.h"
+#include "nsIInputStream.h"
+#include "nsStringStream.h"
+
+namespace mozilla {
+namespace dom {
+
+bool
+URLParams::Has(const nsAString& aName)
+{
+ for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) {
+ if (mParams[i].mKey.Equals(aName)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void
+URLParams::Get(const nsAString& aName, nsString& aRetval)
+{
+ SetDOMStringToNull(aRetval);
+
+ for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) {
+ if (mParams[i].mKey.Equals(aName)) {
+ aRetval.Assign(mParams[i].mValue);
+ break;
+ }
+ }
+}
+
+void
+URLParams::GetAll(const nsAString& aName, nsTArray<nsString>& aRetval)
+{
+ aRetval.Clear();
+
+ for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) {
+ if (mParams[i].mKey.Equals(aName)) {
+ aRetval.AppendElement(mParams[i].mValue);
+ }
+ }
+}
+
+void
+URLParams::Append(const nsAString& aName, const nsAString& aValue)
+{
+ Param* param = mParams.AppendElement();
+ param->mKey = aName;
+ param->mValue = aValue;
+}
+
+void
+URLParams::Set(const nsAString& aName, const nsAString& aValue)
+{
+ Param* param = nullptr;
+ for (uint32_t i = 0, len = mParams.Length(); i < len;) {
+ if (!mParams[i].mKey.Equals(aName)) {
+ ++i;
+ continue;
+ }
+ if (!param) {
+ param = &mParams[i];
+ ++i;
+ continue;
+ }
+ // Remove duplicates.
+ mParams.RemoveElementAt(i);
+ --len;
+ }
+
+ if (!param) {
+ param = mParams.AppendElement();
+ param->mKey = aName;
+ }
+
+ param->mValue = aValue;
+}
+
+bool
+URLParams::Delete(const nsAString& aName)
+{
+ bool found = false;
+ for (uint32_t i = 0; i < mParams.Length();) {
+ if (mParams[i].mKey.Equals(aName)) {
+ mParams.RemoveElementAt(i);
+ found = true;
+ } else {
+ ++i;
+ }
+ }
+
+ return found;
+}
+
+void
+URLParams::ConvertString(const nsACString& aInput, nsAString& aOutput)
+{
+ aOutput.Truncate();
+
+ if (!mDecoder) {
+ mDecoder = EncodingUtils::DecoderForEncoding("UTF-8");
+ if (!mDecoder) {
+ MOZ_ASSERT(mDecoder, "Failed to create a decoder.");
+ return;
+ }
+ }
+
+ int32_t inputLength = aInput.Length();
+ int32_t outputLength = 0;
+
+ nsresult rv = mDecoder->GetMaxLength(aInput.BeginReading(), inputLength,
+ &outputLength);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ if (!aOutput.SetLength(outputLength, fallible)) {
+ return;
+ }
+
+ int32_t newOutputLength = outputLength;
+ rv = mDecoder->Convert(aInput.BeginReading(), &inputLength,
+ aOutput.BeginWriting(), &newOutputLength);
+ if (NS_FAILED(rv)) {
+ aOutput.Truncate();
+ return;
+ }
+ if (newOutputLength < outputLength) {
+ aOutput.Truncate(newOutputLength);
+ }
+}
+
+void
+URLParams::DecodeString(const nsACString& aInput, nsAString& aOutput)
+{
+ nsACString::const_iterator start, end;
+ aInput.BeginReading(start);
+ aInput.EndReading(end);
+
+ nsCString unescaped;
+
+ while (start != end) {
+ // replace '+' with U+0020
+ if (*start == '+') {
+ unescaped.Append(' ');
+ ++start;
+ continue;
+ }
+
+ // Percent decode algorithm
+ if (*start == '%') {
+ nsACString::const_iterator first(start);
+ ++first;
+
+ nsACString::const_iterator second(first);
+ ++second;
+
+#define ASCII_HEX_DIGIT( x ) \
+ ((x >= 0x41 && x <= 0x46) || \
+ (x >= 0x61 && x <= 0x66) || \
+ (x >= 0x30 && x <= 0x39))
+
+#define HEX_DIGIT( x ) \
+ (*x >= 0x30 && *x <= 0x39 \
+ ? *x - 0x30 \
+ : (*x >= 0x41 && *x <= 0x46 \
+ ? *x - 0x37 \
+ : *x - 0x57))
+
+ if (first != end && second != end &&
+ ASCII_HEX_DIGIT(*first) && ASCII_HEX_DIGIT(*second)) {
+ unescaped.Append(HEX_DIGIT(first) * 16 + HEX_DIGIT(second));
+ start = ++second;
+ continue;
+
+ } else {
+ unescaped.Append('%');
+ ++start;
+ continue;
+ }
+ }
+
+ unescaped.Append(*start);
+ ++start;
+ }
+
+ ConvertString(unescaped, aOutput);
+}
+
+void
+URLParams::ParseInput(const nsACString& aInput)
+{
+ // Remove all the existing data before parsing a new input.
+ DeleteAll();
+
+ nsACString::const_iterator start, end;
+ aInput.BeginReading(start);
+ aInput.EndReading(end);
+ nsACString::const_iterator iter(start);
+
+ while (start != end) {
+ nsAutoCString string;
+
+ if (FindCharInReadable('&', iter, end)) {
+ string.Assign(Substring(start, iter));
+ start = ++iter;
+ } else {
+ string.Assign(Substring(start, end));
+ start = end;
+ }
+
+ if (string.IsEmpty()) {
+ continue;
+ }
+
+ nsACString::const_iterator eqStart, eqEnd;
+ string.BeginReading(eqStart);
+ string.EndReading(eqEnd);
+ nsACString::const_iterator eqIter(eqStart);
+
+ nsAutoCString name;
+ nsAutoCString value;
+
+ if (FindCharInReadable('=', eqIter, eqEnd)) {
+ name.Assign(Substring(eqStart, eqIter));
+
+ ++eqIter;
+ value.Assign(Substring(eqIter, eqEnd));
+ } else {
+ name.Assign(string);
+ }
+
+ nsAutoString decodedName;
+ DecodeString(name, decodedName);
+
+ nsAutoString decodedValue;
+ DecodeString(value, decodedValue);
+
+ Append(decodedName, decodedValue);
+ }
+}
+
+namespace {
+
+void SerializeString(const nsCString& aInput, nsAString& aValue)
+{
+ const unsigned char* p = (const unsigned char*) aInput.get();
+ const unsigned char* end = p + aInput.Length();
+
+ while (p != end) {
+ // ' ' to '+'
+ if (*p == 0x20) {
+ aValue.Append(0x2B);
+ // Percent Encode algorithm
+ } else if (*p == 0x2A || *p == 0x2D || *p == 0x2E ||
+ (*p >= 0x30 && *p <= 0x39) ||
+ (*p >= 0x41 && *p <= 0x5A) || *p == 0x5F ||
+ (*p >= 0x61 && *p <= 0x7A)) {
+ aValue.Append(*p);
+ } else {
+ aValue.AppendPrintf("%%%.2X", *p);
+ }
+
+ ++p;
+ }
+}
+
+} // namespace
+
+void
+URLParams::Serialize(nsAString& aValue) const
+{
+ aValue.Truncate();
+ bool first = true;
+
+ for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) {
+ if (first) {
+ first = false;
+ } else {
+ aValue.Append('&');
+ }
+
+ SerializeString(NS_ConvertUTF16toUTF8(mParams[i].mKey), aValue);
+ aValue.Append('=');
+ SerializeString(NS_ConvertUTF16toUTF8(mParams[i].mValue), aValue);
+ }
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(URLSearchParams, mParent, mObserver)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(URLSearchParams)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(URLSearchParams)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(URLSearchParams)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsIXHRSendable)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+URLSearchParams::URLSearchParams(nsISupports* aParent,
+ URLSearchParamsObserver* aObserver)
+ : mParams(new URLParams())
+ , mParent(aParent)
+ , mObserver(aObserver)
+{
+}
+
+URLSearchParams::URLSearchParams(nsISupports* aParent,
+ const URLSearchParams& aOther)
+ : mParams(new URLParams(*aOther.mParams.get()))
+ , mParent(aParent)
+ , mObserver(nullptr)
+{
+}
+
+URLSearchParams::~URLSearchParams()
+{
+ DeleteAll();
+}
+
+JSObject*
+URLSearchParams::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return URLSearchParamsBinding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */ already_AddRefed<URLSearchParams>
+URLSearchParams::Constructor(const GlobalObject& aGlobal,
+ const nsAString& aInit,
+ ErrorResult& aRv)
+{
+ RefPtr<URLSearchParams> sp =
+ new URLSearchParams(aGlobal.GetAsSupports(), nullptr);
+
+ NS_ConvertUTF16toUTF8 input(aInit);
+
+ if (StringBeginsWith(input, NS_LITERAL_CSTRING("?"))) {
+ sp->ParseInput(Substring(input, 1, input.Length() - 1));
+ } else {
+ sp->ParseInput(input);
+ }
+
+ return sp.forget();
+}
+
+/* static */ already_AddRefed<URLSearchParams>
+URLSearchParams::Constructor(const GlobalObject& aGlobal,
+ URLSearchParams& aInit,
+ ErrorResult& aRv)
+{
+ RefPtr<URLSearchParams> sp =
+ new URLSearchParams(aGlobal.GetAsSupports(), aInit);
+
+ return sp.forget();
+}
+
+void
+URLSearchParams::ParseInput(const nsACString& aInput)
+{
+ mParams->ParseInput(aInput);
+}
+
+void
+URLSearchParams::Get(const nsAString& aName, nsString& aRetval)
+{
+ return mParams->Get(aName, aRetval);
+}
+
+void
+URLSearchParams::GetAll(const nsAString& aName, nsTArray<nsString>& aRetval)
+{
+ return mParams->GetAll(aName, aRetval);
+}
+
+void
+URLSearchParams::Set(const nsAString& aName, const nsAString& aValue)
+{
+ mParams->Set(aName, aValue);
+ NotifyObserver();
+}
+
+void
+URLSearchParams::Append(const nsAString& aName, const nsAString& aValue)
+{
+ mParams->Append(aName, aValue);
+ NotifyObserver();
+}
+
+bool
+URLSearchParams::Has(const nsAString& aName)
+{
+ return mParams->Has(aName);
+}
+
+void
+URLSearchParams::Delete(const nsAString& aName)
+{
+ if (mParams->Delete(aName)) {
+ NotifyObserver();
+ }
+}
+
+void
+URLSearchParams::DeleteAll()
+{
+ mParams->DeleteAll();
+}
+
+void
+URLSearchParams::Serialize(nsAString& aValue) const
+{
+ mParams->Serialize(aValue);
+}
+
+void
+URLSearchParams::NotifyObserver()
+{
+ if (mObserver) {
+ mObserver->URLSearchParamsUpdated(this);
+ }
+}
+
+uint32_t
+URLSearchParams::GetIterableLength() const
+{
+ return mParams->Length();
+}
+
+const nsAString&
+URLSearchParams::GetKeyAtIndex(uint32_t aIndex) const
+{
+ return mParams->GetKeyAtIndex(aIndex);
+}
+
+const nsAString&
+URLSearchParams::GetValueAtIndex(uint32_t aIndex) const
+{
+ return mParams->GetValueAtIndex(aIndex);
+}
+
+// Helper functions for structured cloning
+inline bool
+ReadString(JSStructuredCloneReader* aReader, nsString& aString)
+{
+ MOZ_ASSERT(aReader);
+
+ bool read;
+ uint32_t nameLength, zero;
+ read = JS_ReadUint32Pair(aReader, &nameLength, &zero);
+ if (!read) {
+ return false;
+ }
+ MOZ_ASSERT(zero == 0);
+ aString.SetLength(nameLength);
+ size_t charSize = sizeof(nsString::char_type);
+ read = JS_ReadBytes(aReader, (void*) aString.BeginWriting(),
+ nameLength * charSize);
+ if (!read) {
+ return false;
+ }
+
+ return true;
+}
+
+inline bool
+WriteString(JSStructuredCloneWriter* aWriter, const nsString& aString)
+{
+ MOZ_ASSERT(aWriter);
+
+ size_t charSize = sizeof(nsString::char_type);
+ return JS_WriteUint32Pair(aWriter, aString.Length(), 0) &&
+ JS_WriteBytes(aWriter, aString.get(), aString.Length() * charSize);
+}
+
+bool
+URLParams::WriteStructuredClone(JSStructuredCloneWriter* aWriter) const
+{
+ const uint32_t& nParams = mParams.Length();
+ if (!JS_WriteUint32Pair(aWriter, nParams, 0)) {
+ return false;
+ }
+ for (uint32_t i = 0; i < nParams; ++i) {
+ if (!WriteString(aWriter, mParams[i].mKey) ||
+ !WriteString(aWriter, mParams[i].mValue)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool
+URLParams::ReadStructuredClone(JSStructuredCloneReader* aReader)
+{
+ MOZ_ASSERT(aReader);
+
+ DeleteAll();
+
+ uint32_t nParams, zero;
+ nsAutoString key, value;
+ if (!JS_ReadUint32Pair(aReader, &nParams, &zero)) {
+ return false;
+ }
+ MOZ_ASSERT(zero == 0);
+ for (uint32_t i = 0; i < nParams; ++i) {
+ if (!ReadString(aReader, key) || !ReadString(aReader, value)) {
+ return false;
+ }
+ Append(key, value);
+ }
+ return true;
+}
+
+bool
+URLSearchParams::WriteStructuredClone(JSStructuredCloneWriter* aWriter) const
+{
+ return mParams->WriteStructuredClone(aWriter);
+}
+
+bool
+URLSearchParams::ReadStructuredClone(JSStructuredCloneReader* aReader)
+{
+ return mParams->ReadStructuredClone(aReader);
+}
+
+NS_IMETHODIMP
+URLSearchParams::GetSendInfo(nsIInputStream** aBody, uint64_t* aContentLength,
+ nsACString& aContentType, nsACString& aCharset)
+{
+ aContentType.AssignLiteral("application/x-www-form-urlencoded");
+ aCharset.AssignLiteral("UTF-8");
+
+ nsAutoString serialized;
+ Serialize(serialized);
+ NS_ConvertUTF16toUTF8 converted(serialized);
+ *aContentLength = converted.Length();
+ return NS_NewCStringInputStream(aBody, converted);
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/url/URLSearchParams.h b/dom/url/URLSearchParams.h
new file mode 100644
index 000000000..4b0aaa991
--- /dev/null
+++ b/dom/url/URLSearchParams.h
@@ -0,0 +1,223 @@
+/* -*- 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 mozilla_dom_URLSearchParams_h
+#define mozilla_dom_URLSearchParams_h
+
+#include "js/StructuredClone.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/ErrorResult.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+#include "nsISupports.h"
+#include "nsIUnicodeDecoder.h"
+#include "nsIXMLHttpRequest.h"
+
+namespace mozilla {
+namespace dom {
+
+class URLSearchParams;
+
+class URLSearchParamsObserver : public nsISupports
+{
+public:
+ virtual ~URLSearchParamsObserver() {}
+
+ virtual void URLSearchParamsUpdated(URLSearchParams* aFromThis) = 0;
+};
+
+// This class is used in BasePrincipal and it's _extremely_ important that the
+// attributes are kept in the correct order. If this changes, please, update
+// BasePrincipal code.
+
+class URLParams final
+{
+public:
+ URLParams() {}
+
+ ~URLParams()
+ {
+ DeleteAll();
+ }
+
+ explicit URLParams(const URLParams& aOther)
+ : mParams(aOther.mParams)
+ {}
+
+ URLParams(const URLParams&& aOther)
+ : mParams(Move(aOther.mParams))
+ {}
+
+ class ForEachIterator
+ {
+ public:
+ virtual bool
+ URLParamsIterator(const nsString& aName, const nsString& aValue) = 0;
+ };
+
+ void
+ ParseInput(const nsACString& aInput);
+
+ bool
+ ForEach(ForEachIterator& aIterator) const
+ {
+ for (uint32_t i = 0; i < mParams.Length(); ++i) {
+ if (!aIterator.URLParamsIterator(mParams[i].mKey, mParams[i].mValue)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ void Serialize(nsAString& aValue) const;
+
+ void Get(const nsAString& aName, nsString& aRetval);
+
+ void GetAll(const nsAString& aName, nsTArray<nsString >& aRetval);
+
+ void Set(const nsAString& aName, const nsAString& aValue);
+
+ void Append(const nsAString& aName, const nsAString& aValue);
+
+ bool Has(const nsAString& aName);
+
+ // Returns true if aName was found and deleted, false otherwise.
+ bool Delete(const nsAString& aName);
+
+ void DeleteAll()
+ {
+ mParams.Clear();
+ }
+
+ uint32_t Length() const
+ {
+ return mParams.Length();
+ }
+
+ const nsAString& GetKeyAtIndex(uint32_t aIndex) const
+ {
+ MOZ_ASSERT(aIndex < mParams.Length());
+ return mParams[aIndex].mKey;
+ }
+
+ const nsAString& GetValueAtIndex(uint32_t aIndex) const
+ {
+ MOZ_ASSERT(aIndex < mParams.Length());
+ return mParams[aIndex].mValue;
+ }
+
+ bool
+ ReadStructuredClone(JSStructuredCloneReader* aReader);
+
+ bool
+ WriteStructuredClone(JSStructuredCloneWriter* aWriter) const;
+
+private:
+ void DecodeString(const nsACString& aInput, nsAString& aOutput);
+ void ConvertString(const nsACString& aInput, nsAString& aOutput);
+
+ struct Param
+ {
+ nsString mKey;
+ nsString mValue;
+ };
+
+ nsTArray<Param> mParams;
+ nsCOMPtr<nsIUnicodeDecoder> mDecoder;
+};
+
+class URLSearchParams final : public nsIXHRSendable,
+ public nsWrapperCache
+{
+ ~URLSearchParams();
+
+public:
+ NS_DECL_NSIXHRSENDABLE
+
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(URLSearchParams)
+
+ explicit URLSearchParams(nsISupports* aParent,
+ URLSearchParamsObserver* aObserver=nullptr);
+
+ URLSearchParams(nsISupports* aParent,
+ const URLSearchParams& aOther);
+
+ // WebIDL methods
+ nsISupports* GetParentObject() const
+ {
+ return mParent;
+ }
+
+ virtual JSObject*
+ WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<URLSearchParams>
+ Constructor(const GlobalObject& aGlobal, const nsAString& aInit,
+ ErrorResult& aRv);
+
+ static already_AddRefed<URLSearchParams>
+ Constructor(const GlobalObject& aGlobal, URLSearchParams& aInit,
+ ErrorResult& aRv);
+
+ void ParseInput(const nsACString& aInput);
+
+ void Serialize(nsAString& aValue) const;
+
+ void Get(const nsAString& aName, nsString& aRetval);
+
+ void GetAll(const nsAString& aName, nsTArray<nsString>& aRetval);
+
+ void Set(const nsAString& aName, const nsAString& aValue);
+
+ void Append(const nsAString& aName, const nsAString& aValue);
+
+ bool Has(const nsAString& aName);
+
+ void Delete(const nsAString& aName);
+
+ uint32_t GetIterableLength() const;
+ const nsAString& GetKeyAtIndex(uint32_t aIndex) const;
+ const nsAString& GetValueAtIndex(uint32_t aIndex) const;
+
+ void Stringify(nsString& aRetval) const
+ {
+ Serialize(aRetval);
+ }
+
+ typedef URLParams::ForEachIterator ForEachIterator;
+
+ bool
+ ForEach(ForEachIterator& aIterator) const
+ {
+ return mParams->ForEach(aIterator);
+
+ return true;
+ }
+
+ bool
+ ReadStructuredClone(JSStructuredCloneReader* aReader);
+
+ bool
+ WriteStructuredClone(JSStructuredCloneWriter* aWriter) const;
+
+private:
+ void AppendInternal(const nsAString& aName, const nsAString& aValue);
+
+ void DeleteAll();
+
+ void NotifyObserver();
+
+ UniquePtr<URLParams> mParams;
+ nsCOMPtr<nsISupports> mParent;
+ RefPtr<URLSearchParamsObserver> mObserver;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif /* mozilla_dom_URLSearchParams_h */
diff --git a/dom/url/moz.build b/dom/url/moz.build
new file mode 100644
index 000000000..628b69101
--- /dev/null
+++ b/dom/url/moz.build
@@ -0,0 +1,27 @@
+# -*- 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/.
+
+EXPORTS.mozilla.dom += [
+ 'URL.h',
+ 'URLSearchParams.h',
+]
+
+UNIFIED_SOURCES += [
+ 'URL.cpp',
+ 'URLSearchParams.cpp',
+]
+
+LOCAL_INCLUDES += [
+ '../workers',
+]
+
+MOCHITEST_MANIFESTS += ['tests/mochitest.ini']
+MOCHITEST_CHROME_MANIFESTS += [ 'tests/chrome.ini' ]
+BROWSER_CHROME_MANIFESTS += [ 'tests/browser.ini' ]
+
+include('/ipc/chromium/chromium-config.mozbuild')
+
+FINAL_LIBRARY = 'xul'
diff --git a/dom/url/tests/browser.ini b/dom/url/tests/browser.ini
new file mode 100644
index 000000000..ad58be903
--- /dev/null
+++ b/dom/url/tests/browser.ini
@@ -0,0 +1,5 @@
+[DEFAULT]
+support-files =
+ empty.html
+
+[browser_download_after_revoke.js]
diff --git a/dom/url/tests/browser_download_after_revoke.js b/dom/url/tests/browser_download_after_revoke.js
new file mode 100644
index 000000000..3e521eafe
--- /dev/null
+++ b/dom/url/tests/browser_download_after_revoke.js
@@ -0,0 +1,53 @@
+function test () {
+ waitForExplicitFinish();
+ gBrowser.selectedTab = gBrowser.addTab();
+
+ function onLoad() {
+ info("Page loaded.");
+ gBrowser.selectedBrowser.removeEventListener("load", onLoad, true);
+
+ var listener = {
+ onOpenWindow: function(aXULWindow) {
+ info("Download window shown...");
+ Services.wm.removeListener(listener);
+
+ function downloadOnLoad() {
+ domwindow.removeEventListener("load", downloadOnLoad, true);
+
+ is(domwindow.document.location.href, "chrome://mozapps/content/downloads/unknownContentType.xul", "Download page appeared");
+
+ domwindow.close();
+ gBrowser.removeTab(gBrowser.selectedTab);
+ finish();
+ }
+
+ var domwindow = aXULWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindow);
+ domwindow.addEventListener("load", downloadOnLoad, true);
+ },
+ onCloseWindow: function(aXULWindow) {},
+ onWindowTitleChange: function(aXULWindow, aNewTitle) {}
+ }
+
+ Services.wm.addListener(listener);
+
+ info("Creating BlobURL and clicking on a HTMLAnchorElement...");
+ ContentTask.spawn(gBrowser.selectedBrowser, null, function() {
+ let blob = new content.Blob(['test'], { type: 'text/plain' });
+ let url = content.URL.createObjectURL(blob);
+
+ let link = content.document.createElement('a');
+ link.href = url;
+ link.download = 'example.txt';
+ content.document.body.appendChild(link);
+ link.click();
+
+ content.URL.revokeObjectURL(url);
+ });
+ }
+
+ gBrowser.selectedBrowser.addEventListener("load", onLoad, true);
+
+ info("Loading download page...");
+ content.location = "http://example.com/browser/dom/url/tests/empty.html";
+}
diff --git a/dom/url/tests/chrome.ini b/dom/url/tests/chrome.ini
new file mode 100644
index 000000000..256fda02b
--- /dev/null
+++ b/dom/url/tests/chrome.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+skip-if = os == 'android'
+support-files =
+ file_url.jsm
+ file_worker_url.jsm
+ test_bug883784.jsm
+ jsm_url_worker.js
+ !/dom/workers/test/dom_worker_helper.js
+
+[test_bug883784.xul]
+[test_url.xul]
+[test_worker_url.xul]
diff --git a/dom/url/tests/empty.html b/dom/url/tests/empty.html
new file mode 100644
index 000000000..358db717d
--- /dev/null
+++ b/dom/url/tests/empty.html
@@ -0,0 +1,2 @@
+<!DOCTYPE HTML>
+<html><body></body></html>
diff --git a/dom/url/tests/file_url.jsm b/dom/url/tests/file_url.jsm
new file mode 100644
index 000000000..a90f8c95d
--- /dev/null
+++ b/dom/url/tests/file_url.jsm
@@ -0,0 +1,22 @@
+this.EXPORTED_SYMBOLS = ['checkFromJSM'];
+
+this.checkFromJSM = function checkFromJSM(ok, is) {
+ Components.utils.importGlobalProperties(['URL', 'Blob']);
+
+ var url = new URL('http://www.example.com');
+ is(url.href, "http://www.example.com/", "JSM should have URL");
+
+ var url2 = new URL('/foobar', url);
+ is(url2.href, "http://www.example.com/foobar", "JSM should have URL - based on another URL");
+
+ var blob = new Blob(['a']);
+ var url = URL.createObjectURL(blob);
+ ok(url, "URL is created!");
+
+ var u = new URL(url);
+ ok(u, "URL created");
+ is(u.origin, "null", "Url doesn't have an origin if created in a JSM");
+
+ URL.revokeObjectURL(url);
+ ok(true, "URL is revoked");
+}
diff --git a/dom/url/tests/file_worker_url.jsm b/dom/url/tests/file_worker_url.jsm
new file mode 100644
index 000000000..d0bbf62fe
--- /dev/null
+++ b/dom/url/tests/file_worker_url.jsm
@@ -0,0 +1,26 @@
+this.EXPORTED_SYMBOLS = ['checkFromJSM'];
+
+Components.utils.importGlobalProperties(['URL']);
+
+this.checkFromJSM = function checkFromJSM(ok, is, finish) {
+ let worker = new ChromeWorker("jsm_url_worker.js");
+ worker.onmessage = function(event) {
+
+ if (event.data.type == 'finish') {
+ finish();
+ } else if (event.data.type == 'url') {
+ URL.revokeObjectURL(event.data.url);
+ } 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);
+ worker.terminate();
+ finish();
+ };
+
+ worker.postMessage(0);
+}
diff --git a/dom/url/tests/jsm_url_worker.js b/dom/url/tests/jsm_url_worker.js
new file mode 100644
index 000000000..539ace40d
--- /dev/null
+++ b/dom/url/tests/jsm_url_worker.js
@@ -0,0 +1,83 @@
+onmessage = function(event) {
+ if (event.data != 0) {
+ var worker = new Worker('jsm_url_worker.js');
+ worker.onmessage = function(event) {
+ postMessage(event.data);
+ }
+
+ worker.postMessage(event.data - 1);
+ return;
+ }
+
+ status = false;
+ try {
+ if ((URL instanceof Object)) {
+ status = true;
+ }
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'URL object:' + URL});
+
+ status = false;
+ var blob = null;
+ try {
+ blob = new Blob([]);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob:' + blob});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(blob);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob URL:' + url});
+
+ status = false;
+ try {
+ URL.revokeObjectURL(url);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob Revoke URL'});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(true);
+ } catch(e) {
+ status = true;
+ }
+
+ postMessage({type: 'status', status: status, msg: 'CreateObjectURL should fail if the arg is not a blob'});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(blob);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob URL2:' + url});
+
+ status = false;
+ try {
+ URL.createObjectURL(new Object());
+ } catch(e) {
+ status = true;
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Exception wanted' });
+
+ postMessage({type: 'url', url: url});
+
+ postMessage({type: 'finish' });
+}
diff --git a/dom/url/tests/mochitest.ini b/dom/url/tests/mochitest.ini
new file mode 100644
index 000000000..3c641ba96
--- /dev/null
+++ b/dom/url/tests/mochitest.ini
@@ -0,0 +1,21 @@
+[DEFAULT]
+support-files =
+ url_worker.js
+ urlApi_worker.js
+ urlSearchParams_worker.js
+ url_exceptions_worker.js
+
+[test_url.html]
+[test_url_data.html]
+[test_url_empty_port.html]
+[test_url_malformedHost.html]
+[test_urlExceptions.html]
+[test_urlSearchParams.html]
+[test_urlSearchParams_utf8.html]
+[test_urlutils_stringify.html]
+[test_worker_url.html]
+[test_worker_urlApi.html]
+[test_worker_url_exceptions.html]
+[test_worker_urlSearchParams.html]
+[test_unknown_url_origin.html]
+[test_bloburl_location.html]
diff --git a/dom/url/tests/test_bloburl_location.html b/dom/url/tests/test_bloburl_location.html
new file mode 100644
index 000000000..3d190e125
--- /dev/null
+++ b/dom/url/tests/test_bloburl_location.html
@@ -0,0 +1,31 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title>Test for blobURL in location</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+ <script type="application/javascript">
+
+var expectedData = null;
+onmessage = function(e) {
+ if (expectedData === null) {
+ expectedData = e.data;
+ } else {
+ is(e.data, expectedData, "Pathname should be not be changed");
+ SimpleTest.finish();
+ }
+}
+
+var ifr = document.createElement('iframe');
+document.body.appendChild(ifr);
+
+ifr.src = "data:html,<script>location=URL.createObjectURL(new%20Blob(['<script>parent.postMessage(location.pathname,\"*\");location.pathname=\"foo\";parent.postMessage(location.pathname,\"*\");<\/s' +'cript>'], {type:\"text/html\"}));<\/script>";
+
+SimpleTest.waitForExplicitFinish();
+
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_bug883784.jsm b/dom/url/tests/test_bug883784.jsm
new file mode 100644
index 000000000..a5747817d
--- /dev/null
+++ b/dom/url/tests/test_bug883784.jsm
@@ -0,0 +1,42 @@
+this.EXPORTED_SYMBOLS = ["Test"];
+
+const { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
+Cu.importGlobalProperties(["URL"]);
+
+this.Test = {
+ start: function(ok, is, finish) {
+ let worker = new ChromeWorker("jsm_url_worker.js");
+ worker.onmessage = function(event) {
+ if (event.data.type == 'status') {
+ ok(event.data.status, event.data.msg);
+ } else if (event.data.type == 'url') {
+ var xhr = Components.classes["@mozilla.org/xmlextras/xmlhttprequest;1"]
+ .createInstance(Components.interfaces.nsIXMLHttpRequest);
+ xhr.open('GET', event.data.url, false);
+ xhr.onreadystatechange = function() {
+ if (xhr.readyState == 4) {
+ ok(true, "Blob readable!");
+ URL.revokeObjectURL(event.data.url);
+ finish();
+ }
+ }
+ xhr.onerror = function() {
+ ok(false, "Blob unreadable, should not happen!");
+ URL.revokeObjectURL(event.data.url);
+ finish();
+ }
+ xhr.send();
+ }
+ };
+
+ var self = this;
+ worker.onerror = function(event) {
+ is(event.target, worker);
+ ok(false, "Worker had an error: " + event.data);
+ self.worker.terminate();
+ finish();
+ };
+
+ worker.postMessage(0);
+ }
+};
diff --git a/dom/url/tests/test_bug883784.xul b/dom/url/tests/test_bug883784.xul
new file mode 100644
index 000000000..4fdcf5eb1
--- /dev/null
+++ b/dom/url/tests/test_bug883784.xul
@@ -0,0 +1,36 @@
+<?xml version="1.0"?>
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<window title="DOM Worker Threads Test"
+ xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ onload="test();">
+
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/>
+ <script type="application/javascript" src="chrome://mochitests/content/chrome/dom/workers/test/dom_worker_helper.js"/>
+
+ <script type="application/javascript">
+ <![CDATA[
+
+ function test()
+ {
+ waitForWorkerFinish();
+
+ Components.utils.import("chrome://mochitests/content/chrome/dom/url/tests/test_bug883784.jsm");
+ Test.start(ok, is, finish);
+ }
+
+ ]]>
+ </script>
+
+ <body xmlns="http://www.w3.org/1999/xhtml">
+ <p id="display"></p>
+ <div id="content" style="display:none;"></div>
+ <pre id="test"></pre>
+ </body>
+ <label id="test-result"/>
+</window>
diff --git a/dom/url/tests/test_unknown_url_origin.html b/dom/url/tests/test_unknown_url_origin.html
new file mode 100644
index 000000000..052bb6ca4
--- /dev/null
+++ b/dom/url/tests/test_unknown_url_origin.html
@@ -0,0 +1,17 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title>Test for unknwon URL.origin</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+ <script type="application/javascript">
+
+ is ((new URL("blob:http://foo.com/bar")).origin, "http://foo.com");
+ is ((new URL("blob:blob:http://foo.com/bar")).origin, "http://foo.com");
+
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_url.html b/dom/url/tests/test_url.html
new file mode 100644
index 000000000..3f3f727d6
--- /dev/null
+++ b/dom/url/tests/test_url.html
@@ -0,0 +1,442 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title>Test URL API</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=887364">Mozilla Bug 887364</a>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=991471">Mozilla Bug 991471</a>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=996055">Mozilla Bug 996055</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+ <script type="application/javascript">
+
+ /** Test for Bug 887364 **/
+ ok("URL" in window, "window.URL exists");
+
+ var tests = [
+ { url: 'http://www.abc.com',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/',
+ origin: 'http://www.abc.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: ''
+ },
+ { url: 'ftp://auser:apw@www.abc.com',
+ base: undefined,
+ error: false,
+ href: 'ftp://auser:apw@www.abc.com/',
+ origin: 'ftp://www.abc.com',
+ protocol: 'ftp:',
+ username: 'auser',
+ password: 'apw',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: ''
+ },
+ { url: 'http://www.abc.com:90/apath/',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com:90/apath/',
+ origin: 'http://www.abc.com:90',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com:90',
+ hostname: 'www.abc.com',
+ port: '90',
+ pathname: '/apath/',
+ search: '',
+ hash: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt#ahash',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt#ahash',
+ origin: 'http://www.abc.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/apath/afile.txt',
+ search: '',
+ hash: '#ahash'
+ },
+ { url: 'http://example.com/?test#hash',
+ base: undefined,
+ error: false,
+ href: 'http://example.com/?test#hash',
+ origin: 'http://example.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'example.com',
+ hostname: 'example.com',
+ port: '',
+ pathname: '/',
+ search: '?test',
+ hash: '#hash'
+ },
+ { url: 'http://example.com/?test',
+ base: undefined,
+ error: false,
+ href: 'http://example.com/?test',
+ origin: 'http://example.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'example.com',
+ hostname: 'example.com',
+ port: '',
+ pathname: '/',
+ search: '?test',
+ hash: ''
+ },
+ { url: 'http://example.com/carrot#question%3f',
+ base: undefined,
+ error: false,
+ hash: '#question%3f'
+ },
+ { url: 'https://example.com:4443?',
+ base: undefined,
+ error: false,
+ protocol: 'https:',
+ port: '4443',
+ pathname: '/',
+ hash: '',
+ search: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt#ahash?asearch',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt#ahash?asearch',
+ protocol: 'http:',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash?asearch',
+ search: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt?asearch#ahash',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt?asearch#ahash',
+ protocol: 'http:',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: '?asearch'
+ },
+ { url: 'http://abc.com/apath/afile.txt?#ahash',
+ base: undefined,
+ error: false,
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: ''
+ },
+ { url: 'http://auser:apassword@www.abc.com:90/apath/afile.txt?asearch#ahash',
+ base: undefined,
+ error: false,
+ protocol: 'http:',
+ username: 'auser',
+ password: 'apassword',
+ host: 'www.abc.com:90',
+ hostname: 'www.abc.com',
+ port: '90',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: '?asearch',
+ origin: 'http://www.abc.com:90'
+ },
+
+ { url: '/foo#bar',
+ base: 'www.test.org',
+ error: true,
+ },
+ { url: '/foo#bar',
+ base: null,
+ error: true,
+ },
+ { url: '/foo#bar',
+ base: 42,
+ error: true,
+ },
+ { url: 'ftp://ftp.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'ftp:',
+ },
+ { url: 'file:///tmp/file',
+ base: undefined,
+ error: false,
+ protocol: 'file:',
+ },
+ { url: 'gopher://gopher.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'gopher:',
+ },
+ { url: 'ws://ws.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'ws:',
+ },
+ { url: 'wss://ws.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'wss:',
+ },
+ { url: 'foo://foo.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'foo:',
+ },
+
+ { url: 'about:blank',
+ base: undefined,
+ error: false,
+ protocol: 'about:',
+ pathname: 'blank',
+ skip_setters: false,
+ },
+
+ { url: 'foo:bar?what#yeah',
+ base: undefined,
+ error: false,
+ protocol: 'foo:',
+ pathname: 'bar',
+ search: '?what',
+ hash: '#yeah',
+ skip_setters: false,
+ },
+ ];
+
+ while(tests.length) {
+ var test = tests.shift();
+
+ var error = false;
+ var url;
+ try {
+ if (test.base) {
+ url = new URL(test.url, test.base);
+ } else {
+ url = new URL(test.url);
+ }
+ } catch(e) {
+ error = true;
+ }
+
+ is(test.error, error, "Error creating URL");
+ if (test.error) {
+ continue;
+ }
+
+ if ('href' in test) is(url.href, test.href, "href");
+ if ('origin' in test) is(url.origin, test.origin, "origin");
+ if ('protocol' in test) is(url.protocol, test.protocol, "protocol");
+ if ('username' in test) is(url.username, test.username, "username");
+ if ('password' in test) is(url.password, test.password, "password");
+ if ('host' in test) is(url.host, test.host, "host");
+ if ('hostname' in test) is(url.hostname, test.hostname, "hostname");
+ if ('port' in test) is(url.port, test.port, "port");
+ if ('pathname' in test) is(url.pathname, test.pathname, "pathname");
+ if ('search' in test) is(url.search, test.search, "search");
+ if ('hash' in test) is(url.hash, test.hash, "hash");
+
+ if ('skip_setters' in test && test.skip_setters == false) {
+ info("Skip setter methods for URL: " + test);
+ continue;
+ }
+
+ url = new URL('https://www.example.net/what#foo?bar');
+ ok(url, "Url exists!");
+
+ if ('href' in test) url.href = test.href;
+ if ('protocol' in test) url.protocol = test.protocol;
+ if ('username' in test && test.username) url.username = test.username;
+ if ('password' in test && test.password) url.password = test.password;
+ if ('host' in test) url.host = test.host;
+ if ('hostname' in test) url.hostname = test.hostname;
+ if ('port' in test) url.port = test.port;
+ if ('pathname' in test) url.pathname = test.pathname;
+ if ('search' in test) url.search = test.search;
+ if ('hash' in test) url.hash = test.hash;
+
+ if ('href' in test) is(url.href, test.href, "href");
+ if ('origin' in test) is(url.origin, test.origin, "origin");
+ if ('protocol' in test) is(url.protocol, test.protocol, "protocol");
+ if ('username' in test) is(url.username, test.username, "username");
+ if ('password' in test) is(url.password, test.password, "password");
+ if ('host' in test) is(url.host, test.host, "host");
+ if ('hostname' in test) is(test.hostname, url.hostname, "hostname");
+ if ('port' in test) is(test.port, url.port, "port");
+ if ('pathname' in test) is(test.pathname, url.pathname, "pathname");
+ if ('search' in test) is(test.search, url.search, "search");
+ if ('hash' in test) is(test.hash, url.hash, "hash");
+
+ if ('href' in test) is (test.href, url + '', 'stringify works');
+ }
+
+ </script>
+
+ <script>
+ /** Test for Bug 991471 **/
+ var url = new URL("http://localhost/");
+ url.hostname = "";
+ url.username = "tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt";
+ url.hostname = "www.mozilla.org";
+ url.username = "";
+ url.hostname = "www.mozilla.org";
+ is(url.href, "http://www.mozilla.org/", "No parsing error with empty host");
+ </script>
+
+ <script>
+ /** Test for Bug 996055 **/
+ var url = new URL("http://localhost/");
+ url.hostname = "";
+ is(url.href, "http://localhost/", "Empty hostname is ignored");
+ </script>
+
+ <script>
+ /** Test for Bug 960014 **/
+ var url = new URL("http://localhost/");
+ url.hostname = "[2001::1]";
+ is(url.hostname, "[2001::1]", "IPv6 hostname");
+ is(url.href, "http://[2001::1]/");
+
+ url.hostname = "[::192.9.5.5]";
+ is(url.hostname, "[::192.9.5.5]", "IPv6 hostname");
+ is(url.href, "http://[::192.9.5.5]/");
+
+ url = new URL("http://localhost/");
+ url.hostname = "[::]";
+ is(url.hostname, "[::]", "IPv6 hostname");
+
+ url = new URL("http://localhost/");
+ url.host = "[2001::1]:30";
+ is(url.hostname, "[2001::1]", "IPv6 hostname");
+ is(url.port, "30", "Port");
+ is(url.host, "[2001::1]:30", "IPv6 host");
+
+ url = new URL("http://localhost/");
+ // This should silently fail since it's missing the brackets
+ url.hostname = "2001::1";
+ is(url.hostname, "localhost", "Setting bad hostname fails");
+ </script>
+
+ <script>
+ var blob = new Blob(['a']);
+ var url = URL.createObjectURL(blob);
+
+ var u = new URL(url);
+ ok(u.origin, 'http://mochi.test:8888', "The URL generated from a blob URI has an origin");
+ </script>
+
+ <script>
+ var blob = new Blob(['a']);
+ var url = URL.createObjectURL(blob);
+
+ var a = document.createElement('A');
+ a.href = url;
+ ok(a.origin, 'http://mochi.test:8888', "The 'a' element has the correct origin");
+ </script>
+
+ <script>
+ var blob = new Blob(['a']);
+ var url = URL.createObjectURL(blob);
+ URL.revokeObjectURL(url);
+ URL.revokeObjectURL(url);
+ ok(true, "Calling revokeObjectURL twice should be ok");
+ </script>
+
+ <script>
+ URL.revokeObjectURL('blob:something');
+ ok(true, "This should not throw.");
+ </script>
+
+ <script>
+ var base = new URL("http:\\\\test.com\\path/to\\file?query\\backslash#hash\\");
+ is(base.href, "http://test.com/path/to/file?query\\backslash#hash\\");
+
+ var url = new URL("..\\", base);
+ is(url.href, "http://test.com/path/");
+
+ url = new URL("\\test", base);
+ is(url.href, "http://test.com/test");
+
+ url = new URL("\\test\\", base);
+ is(url.href, "http://test.com/test/");
+
+ url = new URL("http://example.org/test", base);
+ is(url.href, "http://example.org/test");
+
+ url = new URL("ftp://tmp/test", base);
+ is(url.href, "ftp://tmp/test");
+
+ url = new URL("ftp:\\\\tmp\\test", base);
+ is(url.href, "ftp://tmp/test");
+
+ url = new URL("scheme://tmp\\test", base);
+ is(url.href, "scheme://tmp\\test");
+ </script>
+
+ <script>
+ var url = new URL("scheme:path/to/file?query#hash");
+ is(url.href, "scheme:path/to/file?query#hash");
+ is(url.pathname, "path/to/file");
+ is(url.search, "?query");
+ is(url.hash, "#hash");
+
+ // pathname cannot be overwritten.
+ url.pathname = "new/path?newquery#newhash";
+ is(url.href, "scheme:path/to/file?query#hash");
+
+ // don't escape '#' until we implement a spec-compliant parser.
+ url.search = "?newquery#newhash";
+ is(url.href, "scheme:path/to/file?newquery#newhash#hash");
+
+ // nulls get encoded, whitespace gets stripped
+ url = new URL("scheme:pa\0\nth/to/fi\0\nle?qu\0\nery#ha\0\nsh");
+ is(url.href, "scheme:pa%00th/to/fi%00le?qu%00ery#ha%00sh");
+
+ url.search = "new\0\nquery";
+ is(url.href, "scheme:pa%00th/to/fi%00le?new%00%0Aquery#ha%00sh");
+ url.hash = "new\0\nhash";
+ is(url.href, "scheme:pa%00th/to/fi%00le?new%00%0Aquery#new%00%0Ahash");
+
+ url = new URL("scheme:path#hash");
+ is(url.href, "scheme:path#hash");
+ url.search = "query";
+ is(url.href, "scheme:path?query#hash");
+ url.hash = "";
+ is(url.href, "scheme:path?query");
+ url.hash = "newhash";
+ is(url.href, "scheme:path?query#newhash");
+ url.search = "";
+ is(url.href, "scheme:path#newhash");
+
+ // we don't implement a spec-compliant parser yet.
+ // make sure we are bug compatible with existing implementations.
+ url = new URL("data:text/html,<a href=\"http://example.org/?q\">Link</a>");
+ is(url.href, "data:text/html,<a%20href=\"http://example.org/?q\">Link</a>");
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_url.xul b/dom/url/tests/test_url.xul
new file mode 100644
index 000000000..026e9df93
--- /dev/null
+++ b/dom/url/tests/test_url.xul
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
+<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+<window title="Test for URL API"
+ xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+ <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
+
+ <!-- test results are displayed in the html:body -->
+ <body xmlns="http://www.w3.org/1999/xhtml">
+ </body>
+
+ <!-- test code goes here -->
+ <script type="application/javascript"><![CDATA[
+
+ /** Test for URL API. **/
+ const Cu = Components.utils;
+
+ // Import our test JSM. We first strip the filename off
+ // the chrome url, then append the jsm filename.
+ var base = /.*\//.exec(window.location.href)[0];
+ Cu.import(base + "file_url.jsm");
+
+ checkFromJSM(ok, is);
+
+ ]]></script>
+</window>
diff --git a/dom/url/tests/test_urlExceptions.html b/dom/url/tests/test_urlExceptions.html
new file mode 100644
index 000000000..b75c9d114
--- /dev/null
+++ b/dom/url/tests/test_urlExceptions.html
@@ -0,0 +1,57 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=926890
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 926890</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=926890">Mozilla Bug 926890</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+ <script type="application/javascript">
+
+ // URL.href throws
+ var url = new URL('http://www.example.com');
+ ok(url, "URL created");
+
+ try {
+ url.href = '42';
+ ok(false, "url.href = 42 should throw");
+ } catch(e) {
+ ok(true, "url.href = 42 should throw");
+ ok(e instanceof TypeError, "error type typeError");
+ }
+
+ url.href = 'http://www.example.org';
+ ok(true, "url.href should not throw");
+
+ try {
+ new URL('42');
+ ok(false, "new URL(42) should throw");
+ } catch(e) {
+ ok(true, "new URL(42) should throw");
+ ok(e instanceof TypeError, "error type typeError");
+ }
+
+ try {
+ new URL('http://www.example.com', '42');
+ ok(false, "new URL(something, 42) should throw");
+ } catch(e) {
+ ok(true, "new URL(something, 42) should throw");
+ ok(e instanceof TypeError, "error type typeError");
+ }
+
+ </script>
+</body>
+</html>
+
diff --git a/dom/url/tests/test_urlSearchParams.html b/dom/url/tests/test_urlSearchParams.html
new file mode 100644
index 000000000..d5a65e1c5
--- /dev/null
+++ b/dom/url/tests/test_urlSearchParams.html
@@ -0,0 +1,334 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=887836
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for URLSearchParams</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=887836">Mozilla Bug 887836</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+<script type="application/javascript">
+
+ /** Test for Bug 887836 **/
+ ok("URLSearchParams" in window, "window.URLSearchParams exists");
+
+ function testSimpleURLSearchParams() {
+ var u = new URLSearchParams();
+ ok(u, "URLSearchParams created");
+ is(u.has('foo'), false, 'URLSearchParams.has(foo)');
+ is(u.get('foo'), null, 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 0, 'URLSearchParams.getAll(foo)');
+
+ u.append('foo', 'bar');
+ is(u.has('foo'), true, 'URLSearchParams.has(foo)');
+ is(u.get('foo'), 'bar', 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 1, 'URLSearchParams.getAll(foo)');
+
+ u.set('foo', 'bar2');
+ is(u.get('foo'), 'bar2', 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 1, 'URLSearchParams.getAll(foo)');
+
+ is(u + "", "foo=bar2", "stringifier");
+
+ u.delete('foo');
+
+ runTest();
+ }
+
+ function testCopyURLSearchParams() {
+ var u = new URLSearchParams();
+ ok(u, "URLSearchParams created");
+ u.append('foo', 'bar');
+
+ var uu = new URLSearchParams(u);
+ is(uu.get('foo'), 'bar', 'uu.get()');
+
+ u.append('foo', 'bar2');
+ is(u.getAll('foo').length, 2, "u.getAll()");
+ is(uu.getAll('foo').length, 1, "uu.getAll()");
+
+ runTest();
+ }
+
+ function testParserURLSearchParams() {
+ var checks = [
+ { input: '', data: {} },
+ { input: 'a', data: { 'a' : [''] } },
+ { input: 'a=b', data: { 'a' : ['b'] } },
+ { input: 'a=', data: { 'a' : [''] } },
+ { input: '=b', data: { '' : ['b'] } },
+ { input: '&', data: {} },
+ { input: '&a', data: { 'a' : [''] } },
+ { input: 'a&', data: { 'a' : [''] } },
+ { input: 'a&a', data: { 'a' : ['', ''] } },
+ { input: 'a&b&c', data: { 'a' : [''], 'b' : [''], 'c' : [''] } },
+ { input: 'a=b&c=d', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: 'a=b&c=d&', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: '&&&a=b&&&&c=d&', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: 'a=a&a=b&a=c', data: { 'a' : ['a', 'b', 'c'] } },
+ { input: 'a==a', data: { 'a' : ['=a'] } },
+ { input: 'a=a+b+c+d', data: { 'a' : ['a b c d'] } },
+ { input: '%=a', data: { '%' : ['a'] } },
+ { input: '%a=a', data: { '%a' : ['a'] } },
+ { input: '%a_=a', data: { '%a_' : ['a'] } },
+ { input: '%61=a', data: { 'a' : ['a'] } },
+ { input: '%=a', data: { '%' : ['a'] } },
+ { input: '%a=a', data: { '%a' : ['a'] } },
+ { input: '%a_=a', data: { '%a_' : ['a'] } },
+ { input: '%61=a', data: { 'a' : ['a'] } },
+ { input: '%61+%4d%4D=', data: { 'a MM' : [''] } },
+ { input: '?a=1', data: { 'a' : ['1'] } },
+ { input: '?', data: {} },
+ { input: '?=b', data: { '' : ['b'] } },
+ ];
+
+ for (var i = 0; i < checks.length; ++i) {
+ var u = new URLSearchParams(checks[i].input);
+
+ var count = 0;
+ for (var key in checks[i].data) {
+ ++count;
+ ok(u.has(key), "key " + key + " found");
+
+ var all = u.getAll(key);
+ is(all.length, checks[i].data[key].length, "same number of elements");
+
+ for (var k = 0; k < all.length; ++k) {
+ is(all[k], checks[i].data[key][k], "value matches");
+ }
+ }
+ }
+
+ runTest();
+ }
+
+ function testURL() {
+ var url = new URL('http://www.example.net?a=b&c=d');
+ ok(url.searchParams, "URL searchParams exists!");
+ ok(url.searchParams.has('a'), "URL.searchParams.has('a')");
+ is(url.searchParams.get('a'), 'b', "URL.searchParams.get('a')");
+ ok(url.searchParams.has('c'), "URL.searchParams.has('c')");
+ is(url.searchParams.get('c'), 'd', "URL.searchParams.get('c')");
+
+ url.searchParams.set('e', 'f');
+ ok(url.href.indexOf('e=f') != 1, 'URL right');
+
+ runTest();
+ }
+
+ function testEncoding() {
+ var encoding = [ [ '1', '1' ],
+ [ 'a b', 'a+b' ],
+ [ '<>', '%3C%3E' ],
+ [ '\u0541', '%D5%81'] ];
+
+ for (var i = 0; i < encoding.length; ++i) {
+ var url = new URL('http://www.example.net');
+ url.searchParams.set('a', encoding[i][0]);
+ is(url.href, 'http://www.example.net/?a=' + encoding[i][1]);
+
+ var url2 = new URL(url.href);
+ is(url2.searchParams.get('a'), encoding[i][0], 'a is still there');
+ }
+
+ runTest();
+ }
+
+ function testOrdering() {
+ var a = new URLSearchParams("a=1&a=2&b=3&c=4&c=5&a=6");
+ is(a.toString(), "a=1&a=2&b=3&c=4&c=5&a=6", "Order is correct");
+ is(a.getAll('a').length, 3, "Correct length of getAll()");
+
+ var b = new URLSearchParams();
+ b.append('a', '1');
+ b.append('b', '2');
+ b.append('a', '3');
+ is(b.toString(), "a=1&b=2&a=3", "Order is correct");
+ is(b.getAll('a').length, 2, "Correct length of getAll()");
+
+ runTest();
+ }
+
+ function testDelete() {
+ var a = new URLSearchParams("a=1&a=2&b=3&c=4&c=5&a=6");
+ is(a.toString(), "a=1&a=2&b=3&c=4&c=5&a=6", "Order is correct");
+ is(a.getAll('a').length, 3, "Correct length of getAll()");
+
+ a.delete('a');
+ is(a.getAll('a').length, 0, "Correct length of getAll()");
+ is(a.toString(), "b=3&c=4&c=5", "Order is correct");
+
+ runTest();
+ }
+
+ function testGetNULL() {
+
+ var u = new URLSearchParams();
+ is(typeof u.get(''), "object", "typeof URL.searchParams.get('')");
+ is(u.get(''), null, "URL.searchParams.get('') should be null");
+
+ var url = new URL('http://www.example.net?a=b');
+ is(url.searchParams.get('b'), null, "URL.searchParams.get('b') should be null");
+ is(url.searchParams.get('a'), 'b', "URL.searchParams.get('a')");
+
+ runTest();
+ }
+
+ function testSet() {
+ var u = new URLSearchParams();
+ u.set('a','b');
+ u.set('e','c');
+ u.set('i','d');
+ u.set('o','f');
+ u.set('u','g');
+
+ is(u.get('a'), 'b', "URL.searchParams.get('a') should return b");
+ is(u.getAll('a').length, 1, "URLSearchParams.getAll('a').length should be 1");
+
+ u.set('a','h1');
+ u.set('a','h2');
+ u.set('a','h3');
+ u.set('a','h4');
+ is(u.get('a'), 'h4', "URL.searchParams.get('a') should return h4");
+ is(u.getAll('a').length, 1, "URLSearchParams.getAll('a').length should be 1");
+
+ is(u.get('e'), 'c', "URL.searchParams.get('e') should return c");
+ is(u.get('i'), 'd', "URL.searchParams.get('i') should return d");
+ is(u.get('o'), 'f', "URL.searchParams.get('o') should return f");
+ is(u.get('u'), 'g', "URL.searchParams.get('u') should return g");
+
+ is(u.getAll('e').length, 1, "URLSearchParams.getAll('e').length should be 1");
+ is(u.getAll('i').length, 1, "URLSearchParams.getAll('i').length should be 1");
+ is(u.getAll('o').length, 1, "URLSearchParams.getAll('o').length should be 1");
+ is(u.getAll('u').length, 1, "URLSearchParams.getAll('u').length should be 1");
+
+ u = new URLSearchParams("name1=value1&name1=value2&name1=value3");
+ is(u.get('name1'), 'value1', "URL.searchParams.get('name1') should return value1");
+ is(u.getAll('name1').length, 3, "URLSearchParams.getAll('name1').length should be 3");
+ u.set('name1','firstPair');
+ is(u.get('name1'), 'firstPair', "URL.searchParams.get('name1') should return firstPair");
+ is(u.getAll('name1').length, 1, "URLSearchParams.getAll('name1').length should be 1");
+
+ runTest();
+ }
+
+ function testIterable() {
+ var u = new URLSearchParams();
+ u.set('1','2');
+ u.set('2','4');
+ u.set('3','6');
+ u.set('4','8');
+ u.set('5','10');
+
+ var key_iter = u.keys();
+ var value_iter = u.values();
+ var entries_iter = u.entries();
+ for (var i = 0; i < 5; ++i) {
+ var v = i + 1;
+ var key = key_iter.next();
+ var value = value_iter.next();
+ var entry = entries_iter.next();
+ is(key.value, v.toString(), "Correct Key iterator: " + v.toString());
+ ok(!key.done, "Key.done is false");
+ is(value.value, (v * 2).toString(), "Correct Value iterator: " + (v * 2).toString());
+ ok(!value.done, "Value.done is false");
+ is(entry.value[0], v.toString(), "Correct Entry 0 iterator: " + v.toString());
+ is(entry.value[1], (v * 2).toString(), "Correct Entry 1 iterator: " + (v * 2).toString());
+ ok(!entry.done, "Entry.done is false");
+ }
+
+ var last = key_iter.next();
+ ok(last.done, "Nothing more to read.");
+ is(last.value, undefined, "Undefined is the last key");
+
+ last = value_iter.next();
+ ok(last.done, "Nothing more to read.");
+ is(last.value, undefined, "Undefined is the last value");
+
+ last = entries_iter.next();
+ ok(last.done, "Nothing more to read.");
+
+ key_iter = u.keys();
+ key_iter.next();
+ key_iter.next();
+ u.delete('1');
+ u.delete('2');
+ u.delete('3');
+ u.delete('4');
+ u.delete('5');
+
+ last = key_iter.next();
+ ok(last.done, "Nothing more to read.");
+ is(last.value, undefined, "Undefined is the last key");
+
+ runTest();
+ }
+
+ function testZeroHandling() {
+ var u = new URLSearchParams;
+ u.set("a", "b\0c");
+ u.set("d\0e", "f");
+ u.set("g\0h", "i\0j");
+ is(u.toString(), "a=b%00c&d%00e=f&g%00h=i%00j",
+ "Should encode U+0000 as %00");
+
+ runTest();
+ }
+
+ function testCopyConstructor() {
+ var url = new URL("http://example.com/");
+ var p = url.searchParams;
+ var q = new URLSearchParams(p);
+ q.set("a", "b");
+ is(url.href, "http://example.com/",
+ "Messing with copy of URLSearchParams should not affect URL");
+ p.set("c", "d");
+ is(url.href, "http://example.com/?c=d",
+ "Messing with URLSearchParams should affect URL");
+
+ runTest();
+ }
+
+ var tests = [
+ testSimpleURLSearchParams,
+ testCopyURLSearchParams,
+ testParserURLSearchParams,
+ testURL,
+ testEncoding,
+ testOrdering,
+ testDelete,
+ testGetNULL,
+ testSet,
+ testIterable,
+ testZeroHandling,
+ testCopyConstructor,
+ ];
+
+ function runTest() {
+ if (!tests.length) {
+ SimpleTest.finish();
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+ }
+
+ SimpleTest.waitForExplicitFinish();
+ runTest();
+
+</script>
+</body>
+</html>
diff --git a/dom/url/tests/test_urlSearchParams_utf8.html b/dom/url/tests/test_urlSearchParams_utf8.html
new file mode 100644
index 000000000..22c85de45
--- /dev/null
+++ b/dom/url/tests/test_urlSearchParams_utf8.html
@@ -0,0 +1,40 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1032511
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 1032511</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1032511">Mozilla Bug 1032511</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+<a href="http://www.example.net?a=b&c=d" id="anchor">foobar</a>
+<area href="http://www.example.net?a=b&c=d" id="area">foobar</area>
+<script type="application/javascript">
+
+ /** Test for Bug 1032511 **/
+ var a = new URLSearchParams("%e2");
+ ok(a, "a exists");
+ is(a.toString(), '=', "The value should be here.");
+
+ a = new URLSearchParams("a%e2");
+ // This is a known decoder bug that fails to emit a REPLACEMENT CHARACTER.
+ is(a.toString(), 'a=', "The value should be here.");
+
+ a = new URLSearchParams("a%e2b");
+ is(a.toString(), 'a%EF%BF%BDb=', "The value should be here.");
+
+</script>
+</body>
+</html>
diff --git a/dom/url/tests/test_url_data.html b/dom/url/tests/test_url_data.html
new file mode 100644
index 000000000..082128f6d
--- /dev/null
+++ b/dom/url/tests/test_url_data.html
@@ -0,0 +1,37 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title>Test URL API - data:plain</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1018682">Mozilla Bug 1018682</a>
+
+<script type="application/javascript">
+
+var base = new URL("data:text/plain,");
+
+base.protocol = "chrome:";
+is(base.protocol, 'data:', "The protocol should not change from data to chrome.");
+
+try {
+ var relative = new URL("a", base);
+ ok(false, "Relative URL from a data:text/plain should not work.");
+} catch(e) {
+ ok(true, "Relative URL from a data:text/plain should not work.");
+}
+
+base.protocol = "http:";
+ok(true, "Protocol: http changed");
+is(base.href, "http://text/plain,", "Base URL is correct");
+
+var relative = new URL("a", base);
+ok(relative, "This works.");
+is(relative.href, "http://text/a", "Relative URL is correct");
+
+</script>
+
+</body>
+</html>
diff --git a/dom/url/tests/test_url_empty_port.html b/dom/url/tests/test_url_empty_port.html
new file mode 100644
index 000000000..f3169730c
--- /dev/null
+++ b/dom/url/tests/test_url_empty_port.html
@@ -0,0 +1,53 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=930450
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 930450</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=930450">Mozilla Bug 930450</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+ <a id="link" href="http://www.example.com:8080">foobar</a>
+ <area id="area" href="http://www.example.com:8080" />
+ <script type="application/javascript">
+
+ var url = new URL('http://www.example.com:8080');
+ is(url.port, '8080', 'URL.port is 8080');
+ url.port = '';
+ is(url.port, '', 'URL.port is \'\'');
+ url.port = 0;
+ is(url.port, '0', 'URL.port is 0');
+
+ var link = document.getElementById("link");
+ is(link.port, '8080', 'URL.port is 8080');
+ link.port = '';
+ is(link.href, 'http://www.example.com/', "link.href matches");
+ is(link.port, '', 'URL.port is \'\'');
+ link.port = 0;
+ is(link.href, 'http://www.example.com:0/', "link.href matches");
+ is(link.port, '0', 'URL.port is 0');
+
+ var area = document.getElementById("area");
+ is(area.port, '8080', 'URL.port is 8080');
+ area.port = '';
+ is(area.href, 'http://www.example.com/', "area.href matches");
+ is(area.port, '', 'URL.port is \'\'');
+ area.port = 0;
+ is(area.href, 'http://www.example.com:0/', "area.href matches");
+ is(area.port, '0', 'URL.port is 0');
+
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_url_malformedHost.html b/dom/url/tests/test_url_malformedHost.html
new file mode 100644
index 000000000..5b813b817
--- /dev/null
+++ b/dom/url/tests/test_url_malformedHost.html
@@ -0,0 +1,48 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1020041
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 1020041</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1020041">Mozilla Bug 1020041</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+ <a id="link" href="http://www.example.com:8080">foobar</a>
+ <area id="area" href="http://www.example.com:8080" />
+ <script type="application/javascript">
+
+ var tests = [
+ { host: '?', expected: 'www.example.com' },
+ { host: 'what?' , expected: 'what' },
+ { host: 'so what' , expected: 'www.example.com' },
+ { host: 'aa#bb' , expected: 'aa' },
+ { host: 'a/b' , expected: 'a' },
+ { host: 'a\\b', expected: 'a' },
+ { host: '[2001::1]#bla:10', expected: '[2001::1]'}
+ ];
+
+ for (var i = 0; i < tests.length; ++i) {
+ var url = new URL('http://www.example.com');
+ url.host = tests[i].host;
+ is (url.host, tests[i].expected, "URL.host is: " + url.host);
+
+ url = new URL('http://www.example.com');
+ url.hostname = tests[i].host;
+ is (url.hostname, tests[i].expected, "URL.hostname is: " + url.host);
+ }
+
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_urlutils_stringify.html b/dom/url/tests/test_urlutils_stringify.html
new file mode 100644
index 000000000..a2b32d45f
--- /dev/null
+++ b/dom/url/tests/test_urlutils_stringify.html
@@ -0,0 +1,38 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=959190
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 959190</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=959190">Mozilla Bug 959190</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ <iframe name="x" id="x"></iframe>
+ <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+ <a id="link" href="http://www.example.com:8080">foobar</a>
+ <area id="area" href="http://www.example.com:8080" />
+ <script type="application/javascript">
+
+ var url = new URL('http://www.example.com:8080');
+ is(url + '', 'http://www.example.com:8080/', 'URL stringify');
+
+ var link = document.getElementById("link");
+ is(link + '', 'http://www.example.com:8080/', 'Anchor stringify');
+
+ var area = document.getElementById("area");
+ is(area + '', 'http://www.example.com:8080/', 'Area stringify');
+
+ is((location + '').indexOf('http://mochi.test:8888/tests/dom/url/tests/test_urlutils_stringify.html'), 0, 'Location stringify');
+ </script>
+</body>
+</html>
diff --git a/dom/url/tests/test_worker_url.html b/dom/url/tests/test_worker_url.html
new file mode 100644
index 000000000..6b010608c
--- /dev/null
+++ b/dom/url/tests/test_worker_url.html
@@ -0,0 +1,67 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for URL object in workers</title>
+ <script type="text/javascript" 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("url_worker.js");
+
+ worker.onmessage = function(event) {
+ is(event.target, worker, "Correct worker");
+
+ if (event.data.type == 'finish') {
+ runTest();
+ } else if (event.data.type == 'status') {
+ ok(event.data.status, event.data.msg);
+ } else if (event.data.type == 'url') {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', event.data.url, false);
+ xhr.onreadystatechange = function() {
+ if (xhr.readyState == 4) {
+ ok(true, "Blob readable!");
+ }
+ }
+ xhr.send();
+ }
+ };
+
+ worker.onerror = function(event) {
+ is(event.target, worker, "Correct worker");
+ ok(false, "Worker had an error: " + event.message);
+ 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/url/tests/test_worker_url.xul b/dom/url/tests/test_worker_url.xul
new file mode 100644
index 000000000..2f4d79b2c
--- /dev/null
+++ b/dom/url/tests/test_worker_url.xul
@@ -0,0 +1,35 @@
+<?xml version="1.0"?>
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<window title="DOM Worker Threads Test"
+ xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ onload="test();">
+
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/>
+
+ <script type="application/javascript">
+ <![CDATA[
+
+ function test()
+ {
+ SimpleTest.waitForExplicitFinish();
+
+ Components.utils.import("chrome://mochitests/content/chrome/dom/url/tests/file_worker_url.jsm");
+ checkFromJSM(ok, is, SimpleTest.finish);
+ }
+
+ ]]>
+ </script>
+
+ <body xmlns="http://www.w3.org/1999/xhtml">
+ <p id="display"></p>
+ <div id="content" style="display:none;"></div>
+ <pre id="test"></pre>
+ </body>
+ <label id="test-result"/>
+</window>
diff --git a/dom/url/tests/test_worker_urlApi.html b/dom/url/tests/test_worker_urlApi.html
new file mode 100644
index 000000000..654d2a197
--- /dev/null
+++ b/dom/url/tests/test_worker_urlApi.html
@@ -0,0 +1,45 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for URL API object in workers</title>
+ <script type="text/javascript" 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("urlApi_worker.js");
+
+ worker.onmessage = function(event) {
+ is(event.target, worker);
+
+ if (event.data.type == 'finish') {
+ SimpleTest.finish();
+ } 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();
+ };
+
+ worker.postMessage(true);
+
+ SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
+
+
diff --git a/dom/url/tests/test_worker_urlSearchParams.html b/dom/url/tests/test_worker_urlSearchParams.html
new file mode 100644
index 000000000..7578d5c35
--- /dev/null
+++ b/dom/url/tests/test_worker_urlSearchParams.html
@@ -0,0 +1,43 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for URLSearchParams object in workers</title>
+ <script type="text/javascript" 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("urlSearchParams_worker.js");
+
+ worker.onmessage = function(event) {
+ is(event.target, worker);
+
+ if (event.data.type == 'finish') {
+ SimpleTest.finish();
+ } 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.message);
+ SimpleTest.finish();
+ };
+
+ worker.postMessage(true);
+
+ SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/url/tests/test_worker_url_exceptions.html b/dom/url/tests/test_worker_url_exceptions.html
new file mode 100644
index 000000000..17993fe4d
--- /dev/null
+++ b/dom/url/tests/test_worker_url_exceptions.html
@@ -0,0 +1,44 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for URL exceptions in workers</title>
+ <script type="text/javascript" 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("url_exceptions_worker.js");
+
+ worker.onmessage = function(event) {
+ is(event.target, worker);
+
+ if (event.data.type == 'finish') {
+ SimpleTest.finish();
+ } 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.message);
+ SimpleTest.finish();
+ };
+
+ worker.postMessage(0);
+ SimpleTest.waitForExplicitFinish();
+
+</script>
+</pre>
+</body>
+</html>
+
+
diff --git a/dom/url/tests/urlApi_worker.js b/dom/url/tests/urlApi_worker.js
new file mode 100644
index 000000000..a8b88e046
--- /dev/null
+++ b/dom/url/tests/urlApi_worker.js
@@ -0,0 +1,272 @@
+function ok(a, msg) {
+ dump("OK: " + !!a + " => " + a + " " + msg + "\n");
+ postMessage({type: 'status', status: !!a, msg: a + ": " + msg });
+}
+
+function is(a, b, msg) {
+ dump("IS: " + (a===b) + " => " + a + " | " + b + " " + msg + "\n");
+ postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg });
+}
+
+onmessage = function() {
+ status = false;
+ try {
+ if ((URL instanceof Object)) {
+ status = true;
+ }
+ } catch(e) {
+ }
+
+ var tests = [
+ { url: 'http://www.abc.com',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/',
+ origin: 'http://www.abc.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: ''
+ },
+ { url: 'ftp://auser:apw@www.abc.com',
+ base: undefined,
+ error: false,
+ href: 'ftp://auser:apw@www.abc.com/',
+ origin: 'ftp://www.abc.com',
+ protocol: 'ftp:',
+ username: 'auser',
+ password: 'apw',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: ''
+ },
+ { url: 'http://www.abc.com:90/apath/',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com:90/apath/',
+ origin: 'http://www.abc.com:90',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com:90',
+ hostname: 'www.abc.com',
+ port: '90',
+ pathname: '/apath/',
+ search: '',
+ hash: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt#ahash',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt#ahash',
+ origin: 'http://www.abc.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'www.abc.com',
+ hostname: 'www.abc.com',
+ port: '',
+ pathname: '/apath/afile.txt',
+ search: '',
+ hash: '#ahash'
+ },
+ { url: 'http://example.com/?test#hash',
+ base: undefined,
+ error: false,
+ href: 'http://example.com/?test#hash',
+ origin: 'http://example.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'example.com',
+ hostname: 'example.com',
+ port: '',
+ pathname: '/',
+ search: '?test',
+ hash: '#hash'
+ },
+ { url: 'http://example.com/?test',
+ base: undefined,
+ error: false,
+ href: 'http://example.com/?test',
+ origin: 'http://example.com',
+ protocol: 'http:',
+ username: '',
+ password: '',
+ host: 'example.com',
+ hostname: 'example.com',
+ port: '',
+ pathname: '/',
+ search: '?test',
+ hash: ''
+ },
+ { url: 'http://example.com/carrot#question%3f',
+ base: undefined,
+ error: false,
+ hash: '#question%3f'
+ },
+ { url: 'https://example.com:4443?',
+ base: undefined,
+ error: false,
+ protocol: 'https:',
+ port: '4443',
+ pathname: '/',
+ hash: '',
+ search: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt#ahash?asearch',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt#ahash?asearch',
+ protocol: 'http:',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash?asearch',
+ search: ''
+ },
+ { url: 'http://www.abc.com/apath/afile.txt?asearch#ahash',
+ base: undefined,
+ error: false,
+ href: 'http://www.abc.com/apath/afile.txt?asearch#ahash',
+ protocol: 'http:',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: '?asearch'
+ },
+ { url: 'http://abc.com/apath/afile.txt?#ahash',
+ base: undefined,
+ error: false,
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: ''
+ },
+ { url: 'http://auser:apassword@www.abc.com:90/apath/afile.txt?asearch#ahash',
+ base: undefined,
+ error: false,
+ protocol: 'http:',
+ username: 'auser',
+ password: 'apassword',
+ host: 'www.abc.com:90',
+ hostname: 'www.abc.com',
+ port: '90',
+ pathname: '/apath/afile.txt',
+ hash: '#ahash',
+ search: '?asearch',
+ origin: 'http://www.abc.com:90'
+ },
+
+ { url: '/foo#bar',
+ base: 'www.test.org',
+ error: true,
+ },
+ { url: '/foo#bar',
+ base: null,
+ error: true,
+ },
+ { url: '/foo#bar',
+ base: 42,
+ error: true,
+ },
+ { url: 'ftp://ftp.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'ftp:',
+ },
+ { url: 'file:///tmp/file',
+ base: undefined,
+ error: false,
+ protocol: 'file:',
+ },
+ { url: 'gopher://gopher.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'gopher:',
+ },
+ { url: 'ws://ws.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'ws:',
+ },
+ { url: 'wss://ws.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'wss:',
+ },
+ { url: 'foo://foo.something.net',
+ base: undefined,
+ error: false,
+ protocol: 'foo:',
+ },
+ ];
+
+ while(tests.length) {
+ var test = tests.shift();
+
+ var error = false;
+ var url;
+ try {
+ if (test.base) {
+ url = new URL(test.url, test.base);
+ } else {
+ url = new URL(test.url);
+ }
+ } catch(e) {
+ error = true;
+ }
+
+ is(test.error, error, "Error creating URL");
+ if (test.error) {
+ continue;
+ }
+
+ if ('href' in test) is(url.href, test.href, "href");
+ if ('origin' in test) is(url.origin, test.origin, "origin");
+ if ('protocol' in test) is(url.protocol, test.protocol, "protocol");
+ if ('username' in test) is(url.username, test.username, "username");
+ if ('password' in test) is(url.password, test.password, "password");
+ if ('host' in test) is(url.host, test.host, "host");
+ if ('hostname' in test) is(url.hostname, test.hostname, "hostname");
+ if ('port' in test) is(url.port, test.port, "port");
+ if ('pathname' in test) is(url.pathname, test.pathname, "pathname");
+ if ('search' in test) is(url.search, test.search, "search");
+ if ('hash' in test) is(url.hash, test.hash, "hash");
+
+ url = new URL('https://www.example.net/what#foo?bar');
+ ok(url, "Url exists!");
+
+ if ('href' in test) url.href = test.href;
+ if ('protocol' in test) url.protocol = test.protocol;
+ if ('username' in test && test.username) url.username = test.username;
+ if ('password' in test && test.password) url.password = test.password;
+ if ('host' in test) url.host = test.host;
+ if ('hostname' in test) url.hostname = test.hostname;
+ if ('port' in test) url.port = test.port;
+ if ('pathname' in test) url.pathname = test.pathname;
+ if ('search' in test) url.search = test.search;
+ if ('hash' in test) url.hash = test.hash;
+
+ if ('href' in test) is(url.href, test.href, "href");
+ if ('origin' in test) is(url.origin, test.origin, "origin");
+ if ('protocol' in test) is(url.protocol, test.protocol, "protocol");
+ if ('username' in test) is(url.username, test.username, "username");
+ if ('password' in test) is(url.password, test.password, "password");
+ if ('host' in test) is(url.host, test.host, "host");
+ if ('hostname' in test) is(test.hostname, url.hostname, "hostname");
+ if ('port' in test) is(test.port, url.port, "port");
+ if ('pathname' in test) is(test.pathname, url.pathname, "pathname");
+ if ('search' in test) is(test.search, url.search, "search");
+ if ('hash' in test) is(test.hash, url.hash, "hash");
+
+ if ('href' in test) is (test.href, url + '', 'stringify works');
+ }
+
+ postMessage({type: 'finish' });
+}
+
diff --git a/dom/url/tests/urlSearchParams_worker.js b/dom/url/tests/urlSearchParams_worker.js
new file mode 100644
index 000000000..03b104f3f
--- /dev/null
+++ b/dom/url/tests/urlSearchParams_worker.js
@@ -0,0 +1,162 @@
+function ok(a, msg) {
+ dump("OK: " + !!a + " => " + a + " " + msg + "\n");
+ postMessage({type: 'status', status: !!a, msg: a + ": " + msg });
+}
+
+function is(a, b, msg) {
+ dump("IS: " + (a===b) + " => " + a + " | " + b + " " + msg + "\n");
+ postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg });
+}
+
+onmessage = function() {
+ status = false;
+ try {
+ if ((URLSearchParams instanceof Object)) {
+ status = true;
+ }
+ } catch(e) {
+ }
+ ok(status, "URLSearchParams in workers \\o/");
+
+ function testSimpleURLSearchParams() {
+ var u = new URLSearchParams();
+ ok(u, "URLSearchParams created");
+ is(u.has('foo'), false, 'URLSearchParams.has(foo)');
+ is(u.get('foo'), null, 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 0, 'URLSearchParams.getAll(foo)');
+
+ u.append('foo', 'bar');
+ is(u.has('foo'), true, 'URLSearchParams.has(foo)');
+ is(u.get('foo'), 'bar', 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 1, 'URLSearchParams.getAll(foo)');
+
+ u.set('foo', 'bar2');
+ is(u.get('foo'), 'bar2', 'URLSearchParams.get(foo)');
+ is(u.getAll('foo').length, 1, 'URLSearchParams.getAll(foo)');
+
+ is(u + "", "foo=bar2", "stringify");
+
+ u.delete('foo');
+
+ runTest();
+ }
+
+ function testCopyURLSearchParams() {
+ var u = new URLSearchParams();
+ ok(u, "URLSearchParams created");
+ u.append('foo', 'bar');
+
+ var uu = new URLSearchParams(u);
+ is(uu.get('foo'), 'bar', 'uu.get()');
+
+ u.append('foo', 'bar2');
+ is(u.getAll('foo').length, 2, "u.getAll()");
+ is(uu.getAll('foo').length, 1, "uu.getAll()");
+
+ runTest();
+ }
+
+ function testParserURLSearchParams() {
+ var checks = [
+ { input: '', data: {} },
+ { input: 'a', data: { 'a' : [''] } },
+ { input: 'a=b', data: { 'a' : ['b'] } },
+ { input: 'a=', data: { 'a' : [''] } },
+ { input: '=b', data: { '' : ['b'] } },
+ { input: '&', data: {} },
+ { input: '&a', data: { 'a' : [''] } },
+ { input: 'a&', data: { 'a' : [''] } },
+ { input: 'a&a', data: { 'a' : ['', ''] } },
+ { input: 'a&b&c', data: { 'a' : [''], 'b' : [''], 'c' : [''] } },
+ { input: 'a=b&c=d', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: 'a=b&c=d&', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: '&&&a=b&&&&c=d&', data: { 'a' : ['b'], 'c' : ['d'] } },
+ { input: 'a=a&a=b&a=c', data: { 'a' : ['a', 'b', 'c'] } },
+ { input: 'a==a', data: { 'a' : ['=a'] } },
+ { input: 'a=a+b+c+d', data: { 'a' : ['a b c d'] } },
+ { input: '%=a', data: { '%' : ['a'] } },
+ { input: '%a=a', data: { '%a' : ['a'] } },
+ { input: '%a_=a', data: { '%a_' : ['a'] } },
+ { input: '%61=a', data: { 'a' : ['a'] } },
+ { input: '%=a', data: { '%' : ['a'] } },
+ { input: '%a=a', data: { '%a' : ['a'] } },
+ { input: '%a_=a', data: { '%a_' : ['a'] } },
+ { input: '%61=a', data: { 'a' : ['a'] } },
+ { input: '%61+%4d%4D=', data: { 'a MM' : [''] } },
+ { input: '?a=1', data: { 'a' : ['1'] } },
+ { input: '?', data: {} },
+ { input: '?=b', data: { '' : ['b'] } },
+ ];
+
+ for (var i = 0; i < checks.length; ++i) {
+ var u = new URLSearchParams(checks[i].input);
+
+ var count = 0;
+ for (var key in checks[i].data) {
+ ++count;
+ ok(u.has(key), "key " + key + " found");
+
+ var all = u.getAll(key);
+ is(all.length, checks[i].data[key].length, "same number of elements");
+
+ for (var k = 0; k < all.length; ++k) {
+ is(all[k], checks[i].data[key][k], "value matches");
+ }
+ }
+ }
+
+ runTest();
+ }
+
+ function testURL() {
+ var url = new URL('http://www.example.net?a=b&c=d');
+ ok(url.searchParams, "URL searchParams exists!");
+ ok(url.searchParams.has('a'), "URL.searchParams.has('a')");
+ is(url.searchParams.get('a'), 'b', "URL.searchParams.get('a')");
+ ok(url.searchParams.has('c'), "URL.searchParams.has('c')");
+ is(url.searchParams.get('c'), 'd', "URL.searchParams.get('c')");
+
+ url.searchParams.set('e', 'f');
+ ok(url.href.indexOf('e=f') != 1, 'URL right');
+
+ runTest();
+ }
+
+ function testEncoding() {
+ var encoding = [ [ '1', '1' ],
+ [ 'a b', 'a+b' ],
+ [ '<>', '%3C%3E' ],
+ [ '\u0541', '%D5%81'] ];
+
+ for (var i = 0; i < encoding.length; ++i) {
+ var url = new URL('http://www.example.net');
+ url.searchParams.set('a', encoding[i][0]);
+ is(url.href, 'http://www.example.net/?a=' + encoding[i][1]);
+
+ var url2 = new URL(url.href);
+ is(url2.searchParams.get('a'), encoding[i][0], 'a is still there');
+ }
+
+ runTest();
+ }
+
+ var tests = [
+ testSimpleURLSearchParams,
+ testCopyURLSearchParams,
+ testParserURLSearchParams,
+ testURL,
+ testEncoding,
+ ];
+
+ function runTest() {
+ if (!tests.length) {
+ postMessage({type: 'finish' });
+ return;
+ }
+
+ var test = tests.shift();
+ test();
+ }
+
+ runTest();
+}
diff --git a/dom/url/tests/url_exceptions_worker.js b/dom/url/tests/url_exceptions_worker.js
new file mode 100644
index 000000000..caefc2202
--- /dev/null
+++ b/dom/url/tests/url_exceptions_worker.js
@@ -0,0 +1,38 @@
+function ok(a, msg) {
+ postMessage({type: 'status', status: !!a, msg: msg });
+}
+
+onmessage = function(event) {
+ // URL.href throws
+ var url = new URL('http://www.example.com');
+ ok(url, "URL created");
+
+ var status = false;
+ try {
+ url.href = '42';
+ } catch(e) {
+ status = true;
+ }
+ ok(status, "url.href = 42 should throw");
+
+ url.href = 'http://www.example.org';
+ ok(true, "url.href should not throw");
+
+ status = false
+ try {
+ new URL('42');
+ } catch(e) {
+ status = true;
+ }
+ ok(status, "new URL(42) should throw");
+
+ status = false
+ try {
+ new URL('http://www.example.com', '42');
+ } catch(e) {
+ status = true;
+ }
+ ok(status, "new URL(something, 42) should throw");
+
+ postMessage({type: 'finish' });
+}
diff --git a/dom/url/tests/url_worker.js b/dom/url/tests/url_worker.js
new file mode 100644
index 000000000..2127acee7
--- /dev/null
+++ b/dom/url/tests/url_worker.js
@@ -0,0 +1,91 @@
+onmessage = function(event) {
+ if (event.data != 0) {
+ var worker = new Worker('url_worker.js');
+ worker.onmessage = function(event) {
+ postMessage(event.data);
+ }
+
+ worker.postMessage(event.data - 1);
+ return;
+ }
+
+ status = false;
+ try {
+ if ((URL instanceof Object)) {
+ status = true;
+ }
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'URL object:' + URL});
+
+ status = false;
+ var blob = null;
+ try {
+ blob = new Blob([]);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob:' + blob});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(blob);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob URL:' + url});
+
+ status = false;
+ try {
+ URL.revokeObjectURL(url);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob Revoke URL'});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(true);
+ } catch(e) {
+ status = true;
+ }
+
+ postMessage({type: 'status', status: status, msg: 'CreateObjectURL should fail if the arg is not a blob'});
+
+ status = false;
+ var url = null;
+ try {
+ url = URL.createObjectURL(blob);
+ status = true;
+ } catch(e) {
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Blob URL2:' + url});
+ postMessage({type: 'url', url: url});
+
+ status = false;
+ try {
+ URL.createObjectURL(new Object());
+ } catch(e) {
+ status = true;
+ }
+
+ postMessage({type: 'status', status: status, msg: 'Exception wanted' });
+
+ var blob = new Blob([123]);
+ var uri = URL.createObjectURL(blob);
+ postMessage({type: 'status', status: !!uri,
+ msg: "The URI has been generated from the blob"});
+
+ var u = new URL(uri);
+ postMessage({type: 'status', status: u.origin == 'http://mochi.test:8888',
+ msg: "The URL generated from a blob URI has an origin."});
+
+ postMessage({type: 'finish' });
+}