wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-07 16:28:38 +09:00
Code Issues Projects Releases Packages Wiki Activity

Bug 1396620 - Part 1: Remove created callback for custom elements

Browse source 
Tag UXP Issue #1344
This commit is contained in:
Gaming4JC 2020-01-20 19:49:20 -05:00 • committed by Roy Tam
commit baa035c5c4
13 changed files with 22 additions and 240 deletions
Download patch file Download diff file Expand all files Collapse all files

77
dom/base/CustomElementRegistry.cpp
View file

@ -21,39 +21,6 @@ CustomElementCallback::Call()
{
IgnoredErrorResult rv;
switch (mType) {
case nsIDocument::eCreated:
{
// For the duration of this callback invocation, the element is being created
// flag must be set to true.
mOwnerData->mElementIsBeingCreated = true;
// The callback hasn't actually been invoked yet, but we need to flip
// this now in order to enqueue the connected callback. This is a spec
// bug (w3c bug 27437).
mOwnerData->mCreatedCallbackInvoked = true;
// If ELEMENT is connected, enqueue connected callback for ELEMENT.
nsIDocument* document = mThisObject->GetComposedDoc();
if (document) {
NodeInfo* ni = mThisObject->NodeInfo();
// We need to do this because at this point, CustomElementDefinition is
// not set to CustomElementData yet, so EnqueueLifecycleCallback will
// fail to find the CE definition for this custom element.
// This will go away eventually since there is no created callback in v1.
CustomElementDefinition* definition =
nsContentUtils::LookupCustomElementDefinition(document,
ni->LocalName(), ni->NamespaceID(),
mOwnerData->GetCustomElementType());
nsContentUtils::EnqueueLifecycleCallback(
nsIDocument::eConnected, mThisObject, nullptr, nullptr, definition);
}
static_cast<LifecycleCreatedCallback *>(mCallback.get())->Call(mThisObject, rv);
mOwnerData->mElementIsBeingCreated = false;
break;
}
case nsIDocument::eConnected:
static_cast<LifecycleConnectedCallback *>(mCallback.get())->Call(mThisObject, rv);
break;
@ -83,12 +50,10 @@ CustomElementCallback::Traverse(nsCycleCollectionTraversalCallback& aCb) const
CustomElementCallback::CustomElementCallback(Element* aThisObject,
nsIDocument::ElementCallbackType aCallbackType,
mozilla::dom::CallbackFunction* aCallback,
CustomElementData* aOwnerData)
mozilla::dom::CallbackFunction* aCallback)
: mThisObject(aThisObject),
mCallback(aCallback),
mType(aCallbackType),
mOwnerData(aOwnerData)
mType(aCallbackType)
{
}
@ -131,9 +96,7 @@ CustomElementData::CustomElementData(nsIAtom* aType)
}
CustomElementData::CustomElementData(nsIAtom* aType, State aState)
: mElementIsBeingCreated(false)
, mCreatedCallbackInvoked(true)
, mState(aState)
: mState(aState)
, mType(aType)
{
}
@ -359,18 +322,12 @@ CustomElementRegistry::CreateCustomElementCallback(
{
MOZ_ASSERT(aDefinition, "CustomElementDefinition should not be null");
RefPtr<CustomElementData> elementData = aCustomElement->GetCustomElementData();
MOZ_ASSERT(elementData, "CustomElementData should exist");
MOZ_ASSERT(aCustomElement->GetCustomElementData(),
"CustomElementData should exist");
// Let CALLBACK be the callback associated with the key NAME in CALLBACKS.
CallbackFunction* func = nullptr;
switch (aType) {
case nsIDocument::eCreated:
if (aDefinition->mCallbacks->mCreatedCallback.WasPassed()) {
func = aDefinition->mCallbacks->mCreatedCallback.Value();
}
break;
case nsIDocument::eConnected:
if (aDefinition->mCallbacks->mConnectedCallback.WasPassed()) {
func = aDefinition->mCallbacks->mConnectedCallback.Value();
@ -401,17 +358,9 @@ CustomElementRegistry::CreateCustomElementCallback(
return nullptr;
}
if (aType == nsIDocument::eCreated) {
elementData->mCreatedCallbackInvoked = false;
} else if (!elementData->mCreatedCallbackInvoked) {
// Callbacks other than created callback must not be enqueued
// until after the created callback has been invoked.
return nullptr;
}
// Add CALLBACK to ELEMENT's callback queue.
auto callback =
MakeUnique<CustomElementCallback>(aCustomElement, aType, func, elementData);
MakeUnique<CustomElementCallback>(aCustomElement, aType, func);
if (aArgs) {
callback->SetArgs(*aArgs);
@ -520,9 +469,7 @@ static const char* kLifeCycleCallbackNames[] = {
"connectedCallback",
"disconnectedCallback",
"adoptedCallback",
"attributeChangedCallback",
// The life cycle callbacks from v0 spec.
"createdCallback"
"attributeChangedCallback"
};
static void
@ -986,11 +933,6 @@ CustomElementRegistry::Upgrade(Element* aElement,
// Step 9.
aElement->SetCustomElementDefinition(aDefinition);
// This is for old spec.
nsContentUtils::EnqueueLifecycleCallback(nsIDocument::eCreated,
aElement, nullptr,
nullptr, aDefinition);
}
//-----------------------------------------------------
@ -1162,11 +1104,6 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(CustomElementDefinition)
cb.NoteXPCOMChild(callbacks->mAttributeChangedCallback.Value());
}
if (callbacks->mCreatedCallback.WasPassed()) {
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mCallbacks->mCreatedCallback");
cb.NoteXPCOMChild(callbacks->mCreatedCallback.Value());
}
if (callbacks->mConnectedCallback.WasPassed()) {
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mCallbacks->mConnectedCallback");
cb.NoteXPCOMChild(callbacks->mConnectedCallback.Value());

11
dom/base/CustomElementRegistry.h
View file

@ -49,8 +49,7 @@ class CustomElementCallback
public:
CustomElementCallback(Element* aThisObject,
nsIDocument::ElementCallbackType aCallbackType,
CallbackFunction* aCallback,
CustomElementData* aOwnerData);
CallbackFunction* aCallback);
void Traverse(nsCycleCollectionTraversalCallback& aCb) const;
void Call();
void SetArgs(LifecycleCallbackArgs& aArgs)
@ -77,9 +76,6 @@ private:
// used by the attribute changed callback.
LifecycleCallbackArgs mArgs;
LifecycleAdoptedCallbackArgs mAdoptedCallbackArgs;
// CustomElementData that contains this callback in the
// callback queue.
CustomElementData* mOwnerData;
};
class CustomElementConstructor final : public CallbackFunction
@ -113,11 +109,6 @@ struct CustomElementData
explicit CustomElementData(nsIAtom* aType);
CustomElementData(nsIAtom* aType, State aState);
// Element is being created flag as described in the custom elements spec.
bool mElementIsBeingCreated;
// Flag to determine if the created callback has been invoked, thus it
// determines if other callbacks can be enqueued.
bool mCreatedCallbackInvoked;
// Custom element state as described in the custom element spec.
State mState;
// custom element reaction queue as described in the custom element spec.

1
dom/base/nsIDocument.h
View file

@ -2579,7 +2579,6 @@ public:
}
enum ElementCallbackType {
eCreated,
eConnected,
eDisconnected,
eAdopted,

4
dom/base/test/chrome/registerElement_ep.js
View file

@ -1,8 +1,8 @@
var proto = Object.create(HTMLElement.prototype);
proto.magicNumber = 42;
proto.createdCallback = function() {
proto.connectedCallback = function() {
finishTest(this.magicNumber === 42);
};
document.registerElement("x-foo", { prototype: proto });
document.createElement("x-foo");
document.firstChild.appendChild(document.createElement("x-foo"));

25
dom/base/test/chrome/test_registerElement_content.xul
View file

@ -21,19 +21,13 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=1130028
<script type="application/javascript"><![CDATA[
/** Test for Bug 1130028 **/
SimpleTest.waitForExplicitFinish();
var connectedCallbackCount = 0;
var createdCallbackCount = 0;
// Callback should be called once by element created in chrome,
// and once by element created in content.
function createdCallbackCalled() {
createdCallbackCount++;
ok(true, "Created callback called, should be called twice in test.");
// Callback should be called only once by element created in content.
function connectedCallbackCalled() {
connectedCallbackCount++;
is(connectedCallbackCount, 1, "Connected callback called, should be called once in test.");
is(this.magicNumber, 42, "Callback should be able to see the custom prototype.");
if (createdCallbackCount == 2) {
SimpleTest.finish();
}
}
function startTests() {
@ -45,10 +39,13 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=1130028
var proto = Object.create(frame.contentWindow.HTMLElement.prototype);
proto.magicNumber = 42;
proto.createdCallback = createdCallbackCalled;
frame.contentDocument.registerElement("x-bar", { prototype: proto });
proto.connectedCallback = connectedCallbackCalled;
frame.contentDocument.createElement("x-bar");
frame.contentDocument.registerElement("x-bar", { prototype: proto });
is(connectedCallbackCount, 1, "Connected callback should be called by element created in content.");
var element = frame.contentDocument.createElement("x-bar");
is(element.magicNumber, 42, "Should be able to see the custom prototype on created element.");
}
]]></script>

4
dom/base/test/chrome/test_registerElement_ep.xul
View file

@ -26,8 +26,8 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=1130028
SimpleTest.waitForExplicitFinish();
function finishTest(canSeePrototype) {
ok(true, "createdCallback called when reigsterElement was called with an extended principal.");
ok(canSeePrototype, "createdCallback should be able to see custom prototype.");
ok(true, "connectedCallback called when reigsterElement was called with an extended principal.");
ok(canSeePrototype, "connectedCallback should be able to see custom prototype.");
SimpleTest.finish();
}

3
dom/tests/mochitest/webcomponents/mochitest.ini
View file

@ -8,16 +8,13 @@ support-files =
[test_bug1176757.html]
[test_bug1276240.html]
[test_content_element.html]
[test_custom_element_adopt_callbacks.html]
[test_custom_element_callback_innerhtml.html]
skip-if = true # disabled - See bug 1390396
[test_custom_element_clone_callbacks_extended.html]
[test_custom_element_htmlconstructor.html]
skip-if = os == 'android' # bug 1323645
support-files =
htmlconstructor_autonomous_tests.js
htmlconstructor_builtin_tests.js
[test_custom_element_import_node_created_callback.html]
[test_custom_element_in_shadow.html]
skip-if = true || stylo # disabled - See bug 1390396 and 1293844
[test_custom_element_register_invalid_callbacks.html]

29
dom/tests/mochitest/webcomponents/test_custom_element_adopt_callbacks.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1081039
-->
<head>
<title>Test callbacks for adopted custom elements.</title>
<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<template id="template"><x-foo></x-foo></template>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1081039">Bug 1081039</a>
<script>
var p = Object.create(HTMLElement.prototype);
p.createdCallback = function() {
ok(false, "Created callback should not be called for adopted node.");
};
document.registerElement("x-foo", { prototype: p });
var template = document.getElementById("template");
var adoptedFoo = document.adoptNode(template.content.firstChild);
is(adoptedFoo.nodeName, "X-FOO");
</script>
</body>
</html>

40
dom/tests/mochitest/webcomponents/test_custom_element_clone_callbacks_extended.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1081039
-->
<head>
<title>Test callbacks for cloned extended custom elements.</title>
<script type="text/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=1081039">Bug 1081039</a>
<script>
SimpleTest.waitForExplicitFinish();
// Test to make sure created callback is called on clones created after
// registering the custom element.
var count = 0;
var p = Object.create(HTMLButtonElement.prototype);
p.createdCallback = function() { // should be called by createElement and cloneNode
is(this.__proto__, p, "Correct prototype should be set on custom elements.");
if (++count == 2) {
SimpleTest.finish();
}
};
document.registerElement("x-foo", { prototype: p, extends: "button" });
var foo = document.createElement("button", {is: "x-foo"});
is(foo.getAttribute("is"), "x-foo");
var fooClone = foo.cloneNode(true);
SimpleTest.waitForExplicitFinish();
</script>
</body>
</html>

34
dom/tests/mochitest/webcomponents/test_custom_element_import_node_created_callback.html
View file

@ -1,34 +0,0 @@
<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1093680
-->
<head>
<title>Test created callback order for imported custom element.</title>
<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<template id="template"><x-foo><span></span></x-foo></template>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1093680">Bug 1093680</a>
<script>
var fooProtoCreatedCallbackCalled = false;
var fooProto = Object.create(HTMLElement.prototype);
fooProto.createdCallback = function() {
ok(this.firstElementChild, "When the created callback is called, the element should already have a child because the callback should only be called after cloning all the contents.");
fooProtoCreatedCallbackCalled = true;
};
document.registerElement("x-foo", { prototype: fooProto });
var template = document.getElementById("template");
// Importing node will implicityly clone the conent in the main document.
var adoptedFoo = document.importNode(template.content, true);
ok(fooProtoCreatedCallbackCalled, "Created callback should be called after importing custom element into document");
</script>
</body>
</html>

1
dom/tests/mochitest/webcomponents/test_custom_element_register_invalid_callbacks.html
View file

@ -19,7 +19,6 @@ const testWindow = iframe.contentDocument.defaultView;
// This is for backward compatibility.
// We should do the same checks for the callbacks from v0 spec.
[
'createdCallback',
'attributeChangedCallback',
].forEach(callback => {
var c = class {};

33
dom/tests/mochitest/webcomponents/test_document_shared_registry.html
View file

@ -14,37 +14,6 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=783129
<script>
var container = document.getElementById("container");
function createdCallbackFromMainDoc() {
var createdCallbackCalled = false;
var assocDoc = document.implementation.createHTMLDocument();
var proto = Object.create(HTMLElement.prototype);
proto.createdCallback = function() {
is(createdCallbackCalled, false, "created callback should only be called once in this tests.");
createdCallbackCalled = true;
runNextTest();
};
assocDoc.registerElement("x-associated-doc-callback-elem", { prototype: proto });
document.createElement("x-associated-doc-callback-elem");
}
function createdCallbackFromDocHTMLNamespace() {
var createdCallbackCalled = false;
var assocDoc = document.implementation.createDocument("http://www.w3.org/1999/xhtml", "html", null);
var somediv = assocDoc.createElement("div");
var proto = Object.create(HTMLElement.prototype);
proto.createdCallback = function() {
is(createdCallbackCalled, false, "created callback should only be called once in this tests.");
createdCallbackCalled = true;
runNextTest();
};
assocDoc.registerElement("x-assoc-doc-with-ns-callback-elem", { prototype: proto });
document.createElement("x-assoc-doc-with-ns-callback-elem");
}
function registerNoRegistryDoc() {
var assocDoc = document.implementation.createDocument(null, "html");
try {
@ -65,8 +34,6 @@ function runNextTest() {
}
var testFunctions = [
createdCallbackFromMainDoc,
createdCallbackFromDocHTMLNamespace,
registerNoRegistryDoc,
SimpleTest.finish
];

2
dom/webidl/WebComponents.webidl
View file

@ -10,7 +10,6 @@
* liability, trademark and document use rules apply.
*/
callback LifecycleCreatedCallback = void();
callback LifecycleConnectedCallback = void();
callback LifecycleDisconnectedCallback = void();
callback LifecycleAdoptedCallback = void(Document? oldDocument,
@ -21,7 +20,6 @@ callback LifecycleAttributeChangedCallback = void(DOMString attrName,
DOMString? namespaceURI);
dictionary LifecycleCallbacks {
LifecycleCreatedCallback? createdCallback;
LifecycleConnectedCallback? connectedCallback;
LifecycleDisconnectedCallback? disconnectedCallback;
LifecycleAdoptedCallback? adoptedCallback;