From 07c8579bd47ca5e4fb6e55ebbc905c0fe7117e52 Mon Sep 17 00:00:00 2001 From: "rniwa@webkit.org" Date: Fri, 8 Jul 2016 01:57:44 +0000 Subject: [PATCH] Replace scoped flag in Event by composed flag https://bugs.webkit.org/show_bug.cgi?id=158415 Reviewed by Chris Dumez. Source/WebCore: Replace `scoped` flag with `composed` flag and negate its meaning per the latest spec: https://dom.spec.whatwg.org/#dom-event-composed https://github.com/w3c/webcomponents/issues/513 In the old spec, every event was assumed to be "composed" (crosses shadow boundaries) by default and there was `scoped` flag which prevented the event from crossing bondaries, and there was a handful of events for which `scoped` was set true when dispatched by UA. In the new spec, every event is assumed to be "scoped" and a handful of user-initiated events set `composed` flag to true, which is also exposed in EventInit dictionary. `relatedTargetScoped` flag has been removed. New behavior is identical to when this flag was set to true. No new tests since existing tests are updated to test the new flag and behavior. * dom/CompositionEvent.cpp: (WebCore::CompositionEvent::isCompositionEvent): Added. * dom/CompositionEvent.h: * dom/Event.cpp: (WebCore::Event::Event): Initialize m_composed. Also re-ordered m_type and m_isInitialized for better packing. (WebCore::Event::composed): Renamed from Event::composed. We return true whenever composed is set to true in EventInit, or the engine is dispatching an user-initiated event listed in: https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937 as well as keypress, cut, paste, and, copy as discussed in: https://github.com/w3c/webcomponents/issues/513#issuecomment-230988170 (WebCore::Event::isCompositionEvent): Added. * dom/Event.h: (WebCore::Event::composed): Added. (WebCore::Event::scoped): Deleted. (WebCore::Event::relatedTargetScoped): Deleted. (WebCore::Event): Reordered m_type and m_isInitialized for better packing. Added m_composed and removed m_scoped and m_relatedTargetScoped. * dom/Event.idl: * dom/EventPath.cpp: (WebCore::shouldEventCrossShadowBoundary): Returns true if the event did not originate from a shadow tree (this event entered the current shadow tree via a slot so we need to proceed with the normal bubble path outside the shadow tree) or composed flag is set true. (WebCore::EventPath::EventPath): m_event no longer exists, which was only used to get the value of relatedTargetScoped which has been removed. (WebCore::EventPath::setRelatedTarget): Behave as if relatedTargetScoped is always set true since the flag has been removed. * dom/EventPath.h: * dom/FocusEvent.cpp: (WebCore::FocusEvent::relatedTargetScoped): Deleted. * dom/FocusEvent.h: * dom/MouseEvent.cpp: (WebCore::MouseEvent::relatedTargetScoped): Deleted. * dom/MouseEvent.h: LayoutTests: Updated the tests to reflect the rename of scoped to composed and the negation of its semantics. Now every Event is assumed to be scoped / non-composed by default, and we need to explicitly set composed to true in order for events to cross shadow boundaries. Also, every Event behaves as if related target is assumed to be scoped in the old terminology althoug the flag no longer exists. * fast/shadow-dom/Extensions-to-Event-Interface-expected.txt: * fast/shadow-dom/Extensions-to-Event-Interface.html: Removed a test case that was testing relatedTargetScoped to false since this flag no longer exists. * fast/shadow-dom/MouseEvent-prototype-offsetX-offsetY.html: * fast/shadow-dom/event-inside-shadow-tree.html: * fast/shadow-dom/event-inside-slotted-node.html: * fast/shadow-dom/event-with-related-target.html: * fast/shadow-dom/trusted-event-scoped-flags-expected.txt: * fast/shadow-dom/trusted-event-scoped-flags.html: * fast/xmlhttprequest/xmlhttprequest-get-expected.txt: * http/tests/workers/worker-importScriptsOnError-expected.txt: * inspector/model/remote-object-get-properties-expected.txt: git-svn-id: http://svn.webkit.org/repository/webkit/trunk@202953 268f45cc-cd09-0410-ab3c-d52691b4dbfc --- LayoutTests/ChangeLog | 27 ++++ ...Extensions-to-Event-Interface-expected.txt | 23 ++-- .../Extensions-to-Event-Interface.html | 116 +++++------------- .../shadow-dom/event-inside-shadow-tree.html | 8 +- .../shadow-dom/event-inside-slotted-node.html | 8 +- .../shadow-dom/event-with-related-target.html | 66 +++++----- .../trusted-event-scoped-flags-expected.txt | 45 +++---- .../trusted-event-scoped-flags.html | 42 +++---- .../xmlhttprequest-get-expected.txt | 80 ------------ .../worker-importScriptsOnError-expected.txt | 48 -------- .../remote-object-get-properties-expected.txt | 6 +- Source/WebCore/ChangeLog | 57 +++++++++ Source/WebCore/dom/CompositionEvent.cpp | 5 + Source/WebCore/dom/CompositionEvent.h | 2 + Source/WebCore/dom/Event.cpp | 41 ++++--- Source/WebCore/dom/Event.h | 13 +- Source/WebCore/dom/Event.idl | 3 +- Source/WebCore/dom/EventPath.cpp | 8 +- Source/WebCore/dom/EventPath.h | 1 - Source/WebCore/dom/FocusEvent.cpp | 5 - Source/WebCore/dom/FocusEvent.h | 2 - Source/WebCore/dom/MouseEvent.cpp | 5 - Source/WebCore/dom/MouseEvent.h | 2 - 23 files changed, 242 insertions(+), 371 deletions(-) delete mode 100644 LayoutTests/fast/xmlhttprequest/xmlhttprequest-get-expected.txt delete mode 100644 LayoutTests/http/tests/workers/worker-importScriptsOnError-expected.txt diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog index 30a2b75f22097..6e7e448f630f1 100644 --- a/LayoutTests/ChangeLog +++ b/LayoutTests/ChangeLog @@ -1,3 +1,30 @@ +2016-07-07 Ryosuke Niwa + + Replace scoped flag in Event by composed flag + https://bugs.webkit.org/show_bug.cgi?id=158415 + + Reviewed by Chris Dumez. + + Updated the tests to reflect the rename of scoped to composed and the negation of its semantics. + Now every Event is assumed to be scoped / non-composed by default, and we need to explicitly set + composed to true in order for events to cross shadow boundaries. + + Also, every Event behaves as if related target is assumed to be scoped in the old terminology + althoug the flag no longer exists. + + * fast/shadow-dom/Extensions-to-Event-Interface-expected.txt: + * fast/shadow-dom/Extensions-to-Event-Interface.html: Removed a test case that was testing + relatedTargetScoped to false since this flag no longer exists. + * fast/shadow-dom/MouseEvent-prototype-offsetX-offsetY.html: + * fast/shadow-dom/event-inside-shadow-tree.html: + * fast/shadow-dom/event-inside-slotted-node.html: + * fast/shadow-dom/event-with-related-target.html: + * fast/shadow-dom/trusted-event-scoped-flags-expected.txt: + * fast/shadow-dom/trusted-event-scoped-flags.html: + * fast/xmlhttprequest/xmlhttprequest-get-expected.txt: + * http/tests/workers/worker-importScriptsOnError-expected.txt: + * inspector/model/remote-object-get-properties-expected.txt: + 2016-05-09 Ryosuke Niwa REGRESSION (198056): Unable to use edit buttons on WordPress diff --git a/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface-expected.txt b/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface-expected.txt index db083e292045a..ba77e0a430438 100644 --- a/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface-expected.txt +++ b/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface-expected.txt @@ -2,20 +2,15 @@ PASS composedPath() must exist on Event PASS composedPath() must return an empty array when the event has not been dispatched PASS composedPath() must return an empty array when the event is no longer dispatched -PASS scoped must exist on Event -PASS scoped on EventInit must default to false -PASS scoped on EventInit must set the scoped flag -PASS relatedTargetScoped must exist on Event -PASS relatedTargetScoped on EventInit must default to false -PASS relatedTargetScoped on EventInit must set the scoped flag -PASS The event must propagate out of open mode shadow boundaries when the scoped flag is unset -PASS The event must propagate out of closed mode shadow boundaries when the scoped flag is unset -PASS The event must not propagate out of open mode shadow boundaries when the scoped flag is set -PASS The event must not propagate out of closed mode shadow boundaries when the scoped flag is set -PASS The event must propagate out of open mode shadow boundaries when the scoped flag is unset on an event with relatedTarget -PASS The event must propagate out of closed mode shadow boundaries when the scoped flag is unset on an event with relatedTarget -PASS The event must not propagate out of open mode shadow boundaries when the scoped flag is set on an event with relatedTarget -PASS The event must not propagate out of closed mode shadow boundaries when the scoped flag is set on an event with relatedTarget +PASS composed must exist on Event +PASS composed on EventInit must default to false +PASS composed on EventInit must set the composed flag +PASS The event must propagate out of open mode shadow boundaries when the composed flag is set +PASS The event must propagate out of closed mode shadow boundaries when the composed flag is set +PASS The event must not propagate out of open mode shadow boundaries when the composed flag is unset +PASS The event must not propagate out of closed mode shadow boundaries when the composed flag is unset +PASS The event must not propagate out of open mode shadow boundaries when the composed flag is unset on an event with relatedTarget +PASS The event must not propagate out of closed mode shadow boundaries when the composed flag is unset on an event with relatedTarget PASS The event must not propagate out of open mode shadow tree of the target but must propagate out of inner shadow trees when the scoped flag is set PASS The event must not propagate out of closed mode shadow tree of the target but must propagate out of inner shadow trees when the scoped flag is set PASS The event must propagate out of open mode shadow tree in which the relative target and the relative related target are the same diff --git a/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface.html b/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface.html index aa5609998a461..2a2763e87e97d 100644 --- a/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface.html +++ b/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface.html @@ -31,40 +31,22 @@ }, 'composedPath() must return an empty array when the event is no longer dispatched'); test(function () { - assert_true('scoped' in Event.prototype); - assert_true('scoped' in new Event('my-event')); -}, 'scoped must exist on Event'); + assert_true('composed' in Event.prototype); + assert_true('composed' in new Event('my-event')); +}, 'composed must exist on Event'); test(function () { var event = new Event('my-event'); - assert_false(event.scoped); -}, 'scoped on EventInit must default to false'); + assert_false(event.composed); +}, 'composed on EventInit must default to false'); test(function () { - var event = new Event('my-event', {scoped: true}); - assert_true(event.scoped); + var event = new Event('my-event', {composed: true}); + assert_true(event.composed); - event = new Event('my-event', {scoped: false}); - assert_false(event.scoped); -}, 'scoped on EventInit must set the scoped flag'); - -test(function () { - assert_true('relatedTargetScoped' in Event.prototype); - assert_true('relatedTargetScoped' in new Event('my-event')); -}, 'relatedTargetScoped must exist on Event'); - -test(function () { - var event = new Event('my-event'); - assert_false(event.relatedTargetScoped); -}, 'relatedTargetScoped on EventInit must default to false'); - -test(function () { - var event = new Event('my-event', {relatedTargetScoped: true}); - assert_true(event.relatedTargetScoped); - - event = new Event('my-event', {relatedTargetScoped: false}); - assert_false(event.relatedTargetScoped); -}, 'relatedTargetScoped on EventInit must set the scoped flag'); + event = new Event('my-event', {composed: false}); + assert_false(event.composed); +}, 'composed on EventInit must set the composed flag'); /* -SR: ShadowRoot -S: Slot target: (~) *: indicates start digit: event path order @@ -76,10 +58,10 @@ + B1b2 */ -function testUnscopedEvent(mode) { +function testComposedEvent(mode) { test(function () { var nodes = createTestTree(mode); - var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {scoped: false, bubbles: true})); + var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {composed: true, bubbles: true})); var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR', 'A']; assert_array_equals(log.eventPath, expectedPath); @@ -88,11 +70,11 @@ assert_array_equals(log.pathAtTargets[1], expectedPath); assert_array_equals(log.pathAtTargets[2], mode == 'open' ? expectedPath : ['A1', 'A-SR', 'A'], 'composedPath must only contain unclosed nodes of the current target.'); - }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is unset'); + }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the composed flag is set'); } -testUnscopedEvent('open'); -testUnscopedEvent('closed'); +testComposedEvent('open'); +testComposedEvent('closed'); /* -SR: ShadowRoot -S: Slot target: (~) *: indicates start digit: event path order @@ -104,53 +86,21 @@ + B1b2 */ -function testScopedEvent(mode) { +function testNonComposedEvent(mode) { test(function () { var nodes = createTestTree(mode); - var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {scoped: true, bubbles: true})); + var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {composed: false, bubbles: true})); var expectedPath = ['A1a', 'A1-SR']; assert_array_equals(log.eventPath, expectedPath); assert_array_equals(log.eventPath.length, log.pathAtTargets.length); assert_array_equals(log.pathAtTargets[0], expectedPath); assert_array_equals(log.pathAtTargets[1], expectedPath); - }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is set'); -} - -testScopedEvent('open'); -testScopedEvent('closed'); - -/* --SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order -A (4) [4] ----------------------- A-SR (3) -+ B ------------ B-SR + A1 (2) ------- A1-SR (1) - + C + B1 --- B1-SR + A2-S [*; 0-3] + A1a (*; 0) - + D --- D-SR + B1a + B1b --- B1b-SR - + D1 + B1c-S + B1b1 - + B1b2 -*/ - -function testUnscopedEventWithUnscopedRelatedTarget(mode) { - test(function () { - var nodes = createTestTree(mode); - var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: false, bubbles: true, relatedTarget: nodes['A2-S']})); - - var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR', 'A']; - var pathExposedToA1 = ['A1', 'A-SR', 'A']; - var pathExposedToA = ['A']; - assert_array_equals(log.eventPath, expectedPath); - assert_array_equals(log.eventPath.length, log.pathAtTargets.length); - assert_array_equals(log.pathAtTargets[0], expectedPath); - assert_array_equals(log.pathAtTargets[1], expectedPath); - assert_array_equals(log.pathAtTargets[2], mode == 'open' ? expectedPath : pathExposedToA1); - assert_array_equals(log.pathAtTargets[3], mode == 'open' ? expectedPath : pathExposedToA1); - assert_array_equals(log.pathAtTargets[4], mode == 'open' ? expectedPath : pathExposedToA); - assert_array_equals(log.relatedTargets, ['A2-S', 'A2-S', 'A2-S', 'A2-S', 'A']); - }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is unset on an event with relatedTarget'); + }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the composed flag is unset'); } -testUnscopedEventWithUnscopedRelatedTarget('open'); -testUnscopedEventWithUnscopedRelatedTarget('closed'); +testNonComposedEvent('open'); +testNonComposedEvent('closed'); /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order @@ -162,10 +112,10 @@ + B1b2 */ -function testScopedEventWithUnscopedRelatedTarget(mode) { +function testNonComposedEventWithRelatedTarget(mode) { test(function () { var nodes = createTestTree(mode); - var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: true, relatedTargetScoped: false, bubbles: true, relatedTarget: nodes['A2-S']})); + var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {composed: false, bubbles: true, relatedTarget: nodes['A2-S']})); var expectedPath = ['A1a', 'A1-SR']; assert_array_equals(log.eventPath, expectedPath); @@ -173,11 +123,11 @@ assert_array_equals(log.pathAtTargets[0], expectedPath); assert_array_equals(log.pathAtTargets[1], expectedPath); assert_array_equals(log.relatedTargets, ['A2-S', 'A2-S']); - }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is set on an event with relatedTarget'); + }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the composed flag is unset on an event with relatedTarget'); } -testScopedEventWithUnscopedRelatedTarget('open'); -testScopedEventWithUnscopedRelatedTarget('closed'); +testNonComposedEventWithRelatedTarget('open'); +testNonComposedEventWithRelatedTarget('closed'); /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order @@ -220,10 +170,10 @@ + B1b2 */ -function testUnscopedEventWithScopedRelatedTarget(mode) { +function testComposedEventWithRelatedTarget(mode) { test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: true, bubbles: true, relatedTarget: nodes['A2-S']})); + log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {composed: true, bubbles: true, relatedTarget: nodes['A2-S']})); var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR']; var pathExposedToA1 = ['A1', 'A-SR']; @@ -237,8 +187,8 @@ }, 'The event must propagate out of ' + mode + ' mode shadow tree in which the relative target and the relative related target are the same'); } -testUnscopedEventWithScopedRelatedTarget('open'); -testUnscopedEventWithScopedRelatedTarget('closed'); +testComposedEventWithRelatedTarget('open'); +testComposedEventWithRelatedTarget('closed'); /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order @@ -250,10 +200,10 @@ + B1b2 */ -function testUnscopedEventWithScopedRelatedTargetThroughSlot(mode) { +function testComposedEventThroughSlot(mode) { test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: true, bubbles: true, relatedTarget: nodes.A1a})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {composed: true, bubbles: true, relatedTarget: nodes.A1a})); var expectedPath = ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A']; var expectedRelatedTarget = ['A', 'A', 'A', 'A', 'A', 'A', 'A1', 'A1', 'A']; @@ -277,8 +227,8 @@ }, 'composedPath() must contain and only contain the unclosed nodes of target in ' + mode + ' mode shadow trees'); } -testUnscopedEventWithScopedRelatedTargetThroughSlot('open'); -testUnscopedEventWithScopedRelatedTargetThroughSlot('closed'); +testComposedEventThroughSlot('open'); +testComposedEventThroughSlot('closed'); diff --git a/LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html b/LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html index c2471ae2295a2..3d5714d8c11bf 100644 --- a/LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html +++ b/LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html @@ -43,7 +43,7 @@ test(function () { var shadow = createShadowRootWithGrandChild(mode); - log = dispatchEventWithLog(shadow.target, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow.target, new Event('foo', {composed: true, bubbles: true})); assert_array_equals(log.length, 4, 'EventPath must contain [target, parent, shadow root, shadow host]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); @@ -62,7 +62,7 @@ var shadow = createShadowRootWithGrandChild(mode); document.body.appendChild(shadow.host); - log = dispatchEventWithLog(shadow.target, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow.target, new Event('foo', {composed: true, bubbles: true})); assert_array_equals(log.length, 7, 'EventPath must contain [target, parent, shadow root, shadow host, body, html, document]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); @@ -100,7 +100,7 @@ test(function () { var shadow = createNestedShadowRoot(innerMode, outerMode); - log = dispatchEventWithLog(shadow.target, new Event('bar', {bubbles: true})); + log = dispatchEventWithLog(shadow.target, new Event('bar', {composed: true, bubbles: true})); assert_array_equals(log.length, 6, 'EventPath must contain [target, inner root, inner host, parent, outer root, outer host]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); @@ -123,7 +123,7 @@ var shadow = createNestedShadowRoot(innerMode, outerMode); document.body.appendChild(shadow.outerHost); - log = dispatchEventWithLog(shadow.target, new Event('bar', {bubbles: true})); + log = dispatchEventWithLog(shadow.target, new Event('bar', {composed: true, bubbles: true})); assert_array_equals(log.length, 6, 'EventPath must contain [target, inner root, inner host, parent, outer root, outer host]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); diff --git a/LayoutTests/fast/shadow-dom/event-inside-slotted-node.html b/LayoutTests/fast/shadow-dom/event-inside-slotted-node.html index a4a2a52f8bc73..d1c4a72bb53da 100644 --- a/LayoutTests/fast/shadow-dom/event-inside-slotted-node.html +++ b/LayoutTests/fast/shadow-dom/event-inside-slotted-node.html @@ -75,7 +75,7 @@ test(function () { var shadow = createShadowHostWithAssignedGrandChild(mode); - log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true})); assert_equals(log.length, 6, 'EventPath must contain [target, target parent, slot, slot parent, shadow root, shadow host]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); @@ -96,7 +96,7 @@ var shadow = createShadowHostWithAssignedGrandChild(mode); document.body.appendChild(shadow.host); - log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true})); assert_equals(log.length, 9, 'EventPath must contain [target, target parent, slot, slot parent, shadow root, shadow host, body, html, document]'); assert_array_equals(log[0], [shadow.target, shadow.target], 'EventPath[0] must be the target'); @@ -174,7 +174,7 @@ test(function () { var shadow = createNestedShadowTreesWithSlots(innerMode, outerUpperMode, outerLowerMode); - log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true})); assert_equals(log.length, 15, 'EventPath must contain 15 targets'); @@ -224,7 +224,7 @@ shadow.deepestNodeInLightDOM = shadow.target; // Needed for dispatchEventWithLog to attach event listeners. shadow.target = shadow.innerSlot; - log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true})); + log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true})); assert_equals(log.length, 12, 'EventPath must contain 12 targets'); diff --git a/LayoutTests/fast/shadow-dom/event-with-related-target.html b/LayoutTests/fast/shadow-dom/event-with-related-target.html index 112bb065eea09..5d2564499c8fd 100644 --- a/LayoutTests/fast/shadow-dom/event-with-related-target.html +++ b/LayoutTests/fast/shadow-dom/event-with-related-target.html @@ -16,23 +16,23 @@ /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order - A (8) --------------------------------------------- A-SR (7) - + B (5) [5-8] --- B-SR (4) + A1 -------- A1-SR - + C + B1 (3) [*; 0-4] --- B1-SR (2) + A2-S (6) + A1a - + D --- D-SR + B1a (*; 0) + B1b [1,2] --- B1b-SR - + D1 + B1c-S (1) + B1b1 - + B1b2 + A ----------------------------------------------- A-SR + + B ----------- B-SR (4) + A1 --- A1-SR + + C + B1 (3) [*; 0-4] --- B1-SR (2) + A2-S + A1a + + D --- D-SR + B1a (*; 0) + B1b [1,2] --- B1b-SR + + D1 + B1c-S (1) + B1b1 + + B1b2 */ function testEventAtB1aWithB1a(mode) { test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1})); assert_array_equals(log.eventPath, - ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); + ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.'); assert_array_equals(log.relatedTargets, - ['B1', 'B1', 'B1', 'B1', 'B1', 'B', 'B', 'B', 'B'], 'The related targets must be correct.'); + ['B1', 'B1', 'B1', 'B1', 'B1'], 'The related targets must be correct.'); }, 'Firing an event at B1a with relatedNode at B1 with ' + mode + ' mode shadow trees'); } @@ -42,23 +42,23 @@ /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order - A (8) -------------------------------------------- A-SR (7) - + B (5) [5-8] --- B-SR (4) + A1 ------ A1-SR - + C + B1 (3) [0,3-4] --- B1-SR (2) + A2-S (6) + A1a - + D --- D-SR + B1a (*; 0) + B1b [1,2] --- B1b-SR - + D1 + B1c-S (1) + B1b1 [*] - + B1b2 + A ------------------------------------------------- A-SR + + B ----------- B-SR (4) + A1 --- A1-SR + + C + B1 (3) [0,3-4] --- B1-SR (2) + A2-S + A1a + + D --- D-SR + B1a (*; 0) + B1b [1,2] --- B1b-SR + + D1 + B1c-S (1) + B1b1 [*] + + B1b2 */ function testEventAtB1aWithB1b1(mode) { test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1b1})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1b1})); assert_array_equals(log.eventPath, - ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); + ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.'); assert_array_equals(log.relatedTargets, - ['B1', 'B1b', 'B1b', 'B1', 'B1', 'B', 'B', 'B', 'B'], 'The related targets must be correct.'); + ['B1', 'B1b', 'B1b', 'B1', 'B1'], 'The related targets must be correct.'); }, 'Firing an event at B1a with relatedNode at B1b1 with ' + mode + ' mode shadow trees'); } @@ -68,23 +68,23 @@ /* -SR: ShadowRoot -S: Slot target: (~) relatedTarget: [~] *: indicates start digit: event path order - A (9) ------------------------------------------------------- A-SR (8) - + B (6) [6-9] --- B-SR (5) + A1 ------ A1-SR - + C + B1 (4) --------- B1-SR (3) + A2-S (7) + A1a - + D --- D-SR + B1a [*; 0-5] + B1b (2) --- B1b-SR (1) - + D1 + B1c-S + B1b1 (*; 0) - + B1b2 + A -------------------------------------------------- A-SR + + B ------------- B-SR (5) + A1 --- A1-SR + + C + B1 (4) ------- B1-SR (3) + A2-S + A1a + + D --- D-SR + B1a [*; 0-5] + B1b (2) --- B1b-SR (1) + + D1 + B1c-S + B1b1 (*; 0) + + B1b2 */ function testEventAtB1b1WithB1a(mode) { test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1b1, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a})); + log = dispatchEventWithLog(nodes, nodes.B1b1, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a})); assert_array_equals(log.eventPath, - ['B1b1', 'B1b-SR', 'B1b', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); + ['B1b1', 'B1b-SR', 'B1b', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.'); assert_array_equals(log.relatedTargets, - ['B1a', 'B1a', 'B1a', 'B1a', 'B1a', 'B1a', 'B', 'B', 'B', 'B'], 'The related targets must be correct.'); + ['B1a', 'B1a', 'B1a', 'B1a', 'B1a', 'B1a'], 'The related targets must be correct.'); }, 'Firing an event at B1b1 with relatedNode at B1a with ' + mode + ' mode shadow trees'); } @@ -105,7 +105,7 @@ test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.D1})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.D1})); assert_array_equals(log.eventPath, ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); @@ -131,7 +131,7 @@ test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.D1, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a})); + log = dispatchEventWithLog(nodes, nodes.D1, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a})); assert_array_equals(log.eventPath, ['D1', 'D-SR', 'D', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); @@ -157,7 +157,7 @@ test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.A1a})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.A1a})); assert_array_equals(log.eventPath, ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); @@ -183,7 +183,7 @@ test(function () { var nodes = createTestTree(mode); - log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a})); + log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a})); assert_array_equals(log.eventPath, ['A1a', 'A1-SR', 'A1', 'A-SR', 'A'], 'The event path must be correct.'); @@ -212,7 +212,7 @@ var nodes = createTestTree(mode); nodes['A-SR'].removeChild(nodes.A1); - log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.A1a})); + log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.A1a})); assert_array_equals(log.eventPath, ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.'); @@ -241,7 +241,7 @@ var nodes = createTestTree(mode); nodes['A-SR'].removeChild(nodes.A1); - log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a})); + log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a})); assert_array_equals(log.eventPath, ['A1a', 'A1-SR', 'A1'], 'The event path must be correct.'); assert_array_equals(log.relatedTargets, ['B', 'B', 'B' ], 'The related targets must be correct.'); diff --git a/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags-expected.txt b/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags-expected.txt index 3abbb8f924c31..4d77557b99115 100644 --- a/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags-expected.txt +++ b/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags-expected.txt @@ -1,65 +1,50 @@ world PASS input.type = "radio"; log(input, "change"); input.click(); eventType is "change" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS log(form, "reset"); form.reset(); eventType is "reset" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS form.focus(); log(input, "focus"); input.focus(); eventType is "focus" -PASS scoped is false -PASS relatedTargetScoped is true +PASS composed is true PASS log(input, "blur"); form.focus(); eventType is "blur" -PASS scoped is false -PASS relatedTargetScoped is true +PASS composed is true PASS input.type = "text"; log(input, "mousemove"); eventSender.mouseMoveTo(x, y); eventType is "mousemove" -PASS scoped is false -PASS relatedTargetScoped is false +PASS composed is true PASS log(input, "mousedown"); eventSender.mouseDown(); eventType is "mousedown" -PASS scoped is false -PASS relatedTargetScoped is false +PASS composed is true PASS log(input, "mouseup"); eventSender.mouseUp(); eventType is "mouseup" -PASS scoped is false -PASS relatedTargetScoped is false +PASS composed is true PASS log(input, "mouseout"); eventSender.mouseMoveTo(0, 0); eventType is "mouseout" -PASS scoped is false -PASS relatedTargetScoped is true +PASS composed is true PASS log(input, "mouseover"); eventSender.mouseMoveTo(x, y); eventType is "mouseover" -PASS scoped is false -PASS relatedTargetScoped is true +PASS composed is true input.value = "hello"; eventSender.mouseMoveTo(input.offsetLeft + 1, y); eventSender.mouseDown(); PASS log(input, "select"); eventSender.mouseMoveTo(input.offsetLeft + input.offsetWidth - 2, y); eventSender.mouseUp(); eventType is "select" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS log(editableElement, "selectstart"); eventSender.mouseMoveTo(editableElement.offsetLeft + 1, y); eventSender.mouseDown(); eventType is "selectstart" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS eventType is "load" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS eventType is "error" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS eventType is "scroll" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS eventType is "resize" -PASS scoped is true -PASS relatedTargetScoped is false +PASS composed is false PASS successfullyParsed is true diff --git a/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags.html b/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags.html index 08f4dc2785219..60f4902760369 100644 --- a/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags.html +++ b/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags.html @@ -8,19 +8,16 @@