diff --git a/README.md b/README.md
index 2c69459f92..bce6376429 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-Official Discord server
+Official Discord server
diff --git a/dom/base/StructuredCloneHolder.cpp b/dom/base/StructuredCloneHolder.cpp
index a7afd310cb..7b7dbdf67d 100644
--- a/dom/base/StructuredCloneHolder.cpp
+++ b/dom/base/StructuredCloneHolder.cpp
@@ -138,6 +138,207 @@ StructuredCloneCallbacksError(JSContext* aCx,
NS_WARNING("Failed to clone data.");
}
+struct SameThreadStreamTransferData
+{
+ SameThreadStreamTransferData(JSContext* aCx, JS::HandleObject aRecord)
+ : mRecord(aCx, aRecord)
+ {}
+
+ ~SameThreadStreamTransferData()
+ {
+ mRecord.reset();
+ }
+
+ JS::PersistentRootedObject mRecord;
+};
+
+bool
+CallStreamTransferHelper(JSContext* aCx,
+ const char* aHelperName,
+ JS::HandleValue aArgument,
+ JS::MutableHandleValue aResult)
+{
+ JS::Rooted global(aCx, JS::CurrentGlobalOrNull(aCx));
+ if (!global) {
+ return false;
+ }
+
+ // Resolve the stream extras lazily before looking up the internal helper.
+ JS::Rooted ignored(aCx);
+ if (!JS_GetProperty(aCx, global, "WritableStream", &ignored)) {
+ return false;
+ }
+
+ JS::Rooted helper(aCx);
+ if (!JS_GetProperty(aCx, global, aHelperName, &helper)) {
+ return false;
+ }
+
+ if (!helper.isObject() || !JS::IsCallable(&helper.toObject())) {
+ aResult.setUndefined();
+ return true;
+ }
+
+ JS::Rooted argument(aCx, aArgument);
+ if (!JS_WrapValue(aCx, &argument)) {
+ return false;
+ }
+
+ return JS::Call(aCx, JS::UndefinedHandleValue, helper,
+ JS::HandleValueArray(argument), aResult);
+}
+
+bool
+TryWriteSameThreadStreamTransfer(JSContext* aCx,
+ JS::Handle aObj,
+ const char* aHelperName,
+ uint32_t aTransferTag,
+ uint32_t* aTag,
+ JS::TransferableOwnership* aOwnership,
+ void** aContent,
+ uint64_t* aExtraData,
+ bool* aHandled)
+{
+ *aHandled = false;
+
+ JS::Rooted argument(aCx, JS::ObjectValue(*aObj));
+ JS::Rooted transferRecord(aCx);
+ if (!CallStreamTransferHelper(aCx, aHelperName, argument, &transferRecord)) {
+ return false;
+ }
+
+ if (transferRecord.isUndefined()) {
+ return true;
+ }
+
+ if (!transferRecord.isObject()) {
+ return false;
+ }
+
+ JS::Rooted record(aCx, &transferRecord.toObject());
+ SameThreadStreamTransferData* data =
+ new SameThreadStreamTransferData(aCx, record);
+
+ *aTag = aTransferTag;
+ *aOwnership = JS::SCTAG_TMO_CUSTOM;
+ *aContent = data;
+ *aExtraData = 0;
+ *aHandled = true;
+ return true;
+}
+
+bool
+TryWriteReadableStreamPortTransfer(JSContext* aCx,
+ JS::Handle aObj,
+ nsTArray& aPortIdentifiers,
+ uint32_t* aTag,
+ JS::TransferableOwnership* aOwnership,
+ void** aContent,
+ uint64_t* aExtraData,
+ bool* aHandled)
+{
+ *aHandled = false;
+
+ JS::Rooted argument(aCx, JS::ObjectValue(*aObj));
+ JS::Rooted transferPortValue(aCx);
+ if (!CallStreamTransferHelper(aCx, "__uxpTransferReadableStreamPort",
+ argument, &transferPortValue)) {
+ return false;
+ }
+
+ if (transferPortValue.isUndefined()) {
+ return true;
+ }
+
+ if (!transferPortValue.isObject()) {
+ return false;
+ }
+
+ JS::Rooted transferPortObj(aCx, &transferPortValue.toObject());
+ MessagePort* port = nullptr;
+ nsresult rv = UNWRAP_OBJECT(MessagePort, &transferPortObj, port);
+ if (NS_FAILED(rv) || !port) {
+ return false;
+ }
+
+ *aExtraData = aPortIdentifiers.Length();
+ MessagePortIdentifier* identifier = aPortIdentifiers.AppendElement();
+ port->CloneAndDisentangle(*identifier);
+
+ *aTag = SCTAG_DOM_TRANSFERRED_READABLESTREAM;
+ *aOwnership = JS::SCTAG_TMO_CUSTOM;
+ *aContent = nullptr;
+ *aHandled = true;
+ return true;
+}
+
+bool
+ReadSameThreadStreamTransfer(JSContext* aCx,
+ void* aContent,
+ const char* aHelperName,
+ JS::MutableHandleObject aReturnObject)
+{
+ MOZ_ASSERT(aContent);
+ SameThreadStreamTransferData* data =
+ static_cast(aContent);
+
+ JS::Rooted record(aCx, JS::ObjectValue(*data->mRecord));
+ JS::Rooted result(aCx);
+ if (!CallStreamTransferHelper(aCx, aHelperName, record, &result)) {
+ return false;
+ }
+
+ if (!result.isObject()) {
+ return false;
+ }
+
+ aReturnObject.set(&result.toObject());
+ delete data;
+ return true;
+}
+
+bool
+ReadReadableStreamPortTransfer(JSContext* aCx,
+ nsISupports* aParent,
+ nsTArray& aPortIdentifiers,
+ uint64_t aExtraData,
+ JS::MutableHandleObject aReturnObject)
+{
+ if (aExtraData >= aPortIdentifiers.Length()) {
+ return false;
+ }
+
+ nsCOMPtr global = do_QueryInterface(aParent);
+
+ ErrorResult rv;
+ RefPtr port =
+ MessagePort::Create(global, aPortIdentifiers[aExtraData], rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ return false;
+ }
+
+ JS::Rooted portValue(aCx);
+ if (!GetOrCreateDOMReflector(aCx, port, &portValue)) {
+ JS_ClearPendingException(aCx);
+ return false;
+ }
+
+ JS::Rooted result(aCx);
+ if (!CallStreamTransferHelper(aCx,
+ "__uxpReceiveReadableStreamTransferFromPort",
+ portValue, &result)) {
+ return false;
+ }
+
+ if (!result.isObject()) {
+ return false;
+ }
+
+ aReturnObject.set(&result.toObject());
+ return true;
+}
+
} // anonymous namespace
const JSStructuredCloneCallbacks StructuredCloneHolder::sCallbacks = {
@@ -1375,6 +1576,35 @@ StructuredCloneHolder::CustomReadTransferHandler(JSContext* aCx,
return true;
}
+ if (mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread) {
+ if (aTag == SCTAG_DOM_TRANSFERRED_WRITABLESTREAM) {
+ return ReadSameThreadStreamTransfer(aCx, aContent,
+ "__uxpReceiveWritableStreamTransfer",
+ aReturnObject);
+ }
+
+ if (aTag == SCTAG_DOM_TRANSFERRED_READABLESTREAM) {
+ return ReadSameThreadStreamTransfer(aCx, aContent,
+ "__uxpReceiveReadableStreamTransfer",
+ aReturnObject);
+ }
+
+ if (aTag == SCTAG_DOM_TRANSFERRED_TRANSFORMSTREAM) {
+ return ReadSameThreadStreamTransfer(aCx, aContent,
+ "__uxpReceiveTransformStreamTransfer",
+ aReturnObject);
+ }
+ }
+
+ if ((mStructuredCloneScope == StructuredCloneScope::SameProcessDifferentThread ||
+ mStructuredCloneScope == StructuredCloneScope::DifferentProcess) &&
+ aTag == SCTAG_DOM_TRANSFERRED_READABLESTREAM) {
+ MOZ_ASSERT(!aContent);
+ return ReadReadableStreamPortTransfer(aCx, mParent, mPortIdentifiers,
+ aExtraData,
+ aReturnObject);
+ }
+
return false;
}
@@ -1443,6 +1673,55 @@ StructuredCloneHolder::CustomWriteTransferHandler(JSContext* aCx,
}
}
+ if (mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread) {
+ bool handled = false;
+ if (!TryWriteSameThreadStreamTransfer(aCx, obj,
+ "__uxpTransferWritableStream",
+ SCTAG_DOM_TRANSFERRED_WRITABLESTREAM,
+ aTag, aOwnership, aContent,
+ aExtraData, &handled)) {
+ return false;
+ }
+ if (handled) {
+ return true;
+ }
+
+ if (!TryWriteSameThreadStreamTransfer(aCx, obj,
+ "__uxpTransferReadableStream",
+ SCTAG_DOM_TRANSFERRED_READABLESTREAM,
+ aTag, aOwnership, aContent,
+ aExtraData, &handled)) {
+ return false;
+ }
+ if (handled) {
+ return true;
+ }
+
+ if (!TryWriteSameThreadStreamTransfer(aCx, obj,
+ "__uxpTransferTransformStream",
+ SCTAG_DOM_TRANSFERRED_TRANSFORMSTREAM,
+ aTag, aOwnership, aContent,
+ aExtraData, &handled)) {
+ return false;
+ }
+ if (handled) {
+ return true;
+ }
+ }
+
+ if (mStructuredCloneScope == StructuredCloneScope::SameProcessDifferentThread ||
+ mStructuredCloneScope == StructuredCloneScope::DifferentProcess) {
+ bool handled = false;
+ if (!TryWriteReadableStreamPortTransfer(aCx, obj, mPortIdentifiers,
+ aTag, aOwnership, aContent,
+ aExtraData, &handled)) {
+ return false;
+ }
+ if (handled) {
+ return true;
+ }
+ }
+
return false;
}
@@ -1480,6 +1759,26 @@ StructuredCloneHolder::CustomFreeTransferHandler(uint32_t aTag,
delete data;
return;
}
+
+ if ((aTag == SCTAG_DOM_TRANSFERRED_WRITABLESTREAM ||
+ aTag == SCTAG_DOM_TRANSFERRED_READABLESTREAM ||
+ aTag == SCTAG_DOM_TRANSFERRED_TRANSFORMSTREAM) &&
+ mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread) {
+ MOZ_ASSERT(aContent);
+ SameThreadStreamTransferData* data =
+ static_cast(aContent);
+ delete data;
+ return;
+ }
+
+ if (aTag == SCTAG_DOM_TRANSFERRED_READABLESTREAM &&
+ (mStructuredCloneScope == StructuredCloneScope::SameProcessDifferentThread ||
+ mStructuredCloneScope == StructuredCloneScope::DifferentProcess)) {
+ MOZ_ASSERT(!aContent);
+ MOZ_ASSERT(aExtraData < mPortIdentifiers.Length());
+ MessagePort::ForceClose(mPortIdentifiers[aExtraData]);
+ return;
+ }
}
bool
diff --git a/dom/base/StructuredCloneTags.h b/dom/base/StructuredCloneTags.h
index 09b91f7afb..15518104f9 100644
--- a/dom/base/StructuredCloneTags.h
+++ b/dom/base/StructuredCloneTags.h
@@ -68,6 +68,11 @@ enum StructuredCloneTags {
// This tag is used by both main thread and workers.
SCTAG_DOM_URLSEARCHPARAMS,
+ // Same-thread transferable stream records. These are not supported by IDB.
+ SCTAG_DOM_TRANSFERRED_READABLESTREAM,
+ SCTAG_DOM_TRANSFERRED_WRITABLESTREAM,
+ SCTAG_DOM_TRANSFERRED_TRANSFORMSTREAM,
+
// When adding a new tag for IDB, please don't add it to the end of the list!
// Tags that are supported by IDB must not ever change. See the static assert
// in IDBObjectStore.cpp, method CommonStructuredCloneReadCallback.
diff --git a/dom/base/nsFrameMessageManager.cpp b/dom/base/nsFrameMessageManager.cpp
index ffb5709e46..a80d9164b9 100644
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -1929,6 +1929,9 @@ public:
{
ProcessGlobal* global = ProcessGlobal::Get();
MOZ_ASSERT(!aRunInGlobalScope);
+ if (NS_WARN_IF(!global)) {
+ return false;
+ }
global->LoadScript(aURL);
return true;
}
diff --git a/dom/base/nsINode.cpp b/dom/base/nsINode.cpp
index 5218938ca3..740c18417f 100644
--- a/dom/base/nsINode.cpp
+++ b/dom/base/nsINode.cpp
@@ -2927,6 +2927,35 @@ FindMatchingElementsWithId(const nsAString& aId, nsINode* aRoot,
// Actually find elements matching aSelectorList (which must not be
// null) and which are descendants of aRoot and put them in aList. If
// onlyFirstMatch, then stop once the first one is found.
+template
+static void
+FindMatchingElementsWithClass(nsINode* aRoot, nsIAtom* aClass,
+ nsCaseTreatment aCaseTreatment, T& aList)
+{
+ Collector results;
+ for (nsIContent* cur = aRoot->GetFirstChild(); cur;
+ cur = cur->GetNextNode(aRoot)) {
+ if (!cur->IsElement()) {
+ continue;
+ }
+ const nsAttrValue* classes = cur->AsElement()->GetClasses();
+ if (classes && classes->Contains(aClass, aCaseTreatment)) {
+ if (onlyFirstMatch) {
+ aList.AppendElement(cur->AsElement());
+ return;
+ }
+ results.AppendElement(cur->AsElement());
+ }
+ }
+ const uint32_t len = results.Length();
+ if (len) {
+ aList.SetCapacity(len);
+ for (uint32_t i = 0; i < len; ++i) {
+ aList.AppendElement(results.ElementAt(i));
+ }
+ }
+}
+
template
MOZ_ALWAYS_INLINE static void
FindMatchingElements(nsINode* aRoot, nsCSSSelectorList* aSelectorList, T &aList,
@@ -2934,6 +2963,23 @@ FindMatchingElements(nsINode* aRoot, nsCSSSelectorList* aSelectorList, T &aList,
{
nsIDocument* doc = aRoot->OwnerDoc();
+ // Parsed selectors are already cached by the document. A lone class needs
+ // only an atom lookup per element, not the general CSS matching context.
+ nsCSSSelector* selector = aSelectorList->mSelectors;
+ if (!aSelectorList->mNext && !selector->mNext &&
+ selector->mClassList && !selector->mClassList->mNext &&
+ !selector->mLowercaseTag && !selector->mIDList &&
+ !selector->mAttrList && !selector->mPseudoClassList &&
+ !selector->mNegations && selector->mNameSpace == kNameSpaceID_Unknown &&
+ selector->IsRestrictedSelector() && !selector->IsHybridPseudoElement()) {
+ nsCaseTreatment caseTreatment =
+ doc->GetCompatibilityMode() == eCompatibility_NavQuirks
+ ? eIgnoreCase : eCaseMatters;
+ FindMatchingElementsWithClass(
+ aRoot, selector->mClassList->mAtom, caseTreatment, aList);
+ return;
+ }
+
TreeMatchContext matchingContext(false, nsRuleWalker::eRelevantLinkUnvisited,
doc, TreeMatchContext::eNeverMatchVisited);
doc->FlushPendingLinkUpdates();
diff --git a/dom/base/test/file_class_selector_checks.js b/dom/base/test/file_class_selector_checks.js
new file mode 100644
index 0000000000..0be76bc6ef
--- /dev/null
+++ b/dom/base/test/file_class_selector_checks.js
@@ -0,0 +1,59 @@
+function checkClassSelectors(parse, equal) {
+ function check(root, selector, expected) {
+ var all = root.querySelectorAll(selector);
+ equal(all.length, expected.length, selector + " count");
+ for (var i = 0; i < expected.length; i++) {
+ equal(all[i].id, expected[i], selector + " order " + i);
+ }
+ equal(root.querySelector(selector), all.length ? all[0] : null,
+ selector + " first match");
+ }
+
+ var doc = parse('' +
+ '' +
+ '
' +
+ '' +
+ '' +
+ '', 'text/html');
+ var root = doc.getElementById('root');
+ for (var repeat = 0; repeat < 10; repeat++) {
+ check(root, '.toggle', ['a', 'b', 'd', 'svg']);
+ check(root, '*|*.toggle', ['a', 'b', 'd', 'svg']);
+ check(root, '.t\\6f ggle', ['a', 'b', 'd', 'svg']);
+ check(root, '.TOGGLE', ['c']);
+ check(root, '.missing', []);
+ check(root, '.toggle.completed', ['a']);
+ check(root, 'button.toggle', ['d']);
+ check(root, '.toggle:not(.completed)', ['b', 'd', 'svg']);
+ check(root, '.toggle, .other', ['a', 'b', 'd', 'svg']);
+ }
+ check(doc, '.toggle', ['root', 'a', 'b', 'd', 'svg']);
+
+ var snapshot = root.querySelectorAll('.toggle');
+ doc.getElementById('a').className = '';
+ root.removeChild(doc.getElementById('d'));
+ doc.getElementById('c').className = 'toggle';
+ check(root, '.toggle', ['b', 'c', 'svg']);
+ equal(snapshot.length, 4, 'querySelectorAll remains a static snapshot');
+ equal(snapshot[0].id, 'a', 'snapshot retains a changed element');
+ equal(snapshot[2].id, 'd', 'snapshot retains a removed element');
+
+ var fragment = doc.createDocumentFragment();
+ fragment.appendChild(root);
+ check(fragment, '.toggle', ['root', 'b', 'c', 'svg']);
+ check(root, '.toggle', ['b', 'c', 'svg']);
+
+ var quirks = parse('' +
+ '', 'text/html');
+ equal(quirks.compatMode, 'BackCompat', 'quirks document');
+ check(quirks, '.toggle', ['lower', 'upper']);
+ check(quirks, '.TOGGLE', ['lower', 'upper']);
+
+ var xml = parse('