Changeset 202953 in webkit


Ignore:
Timestamp:
Jul 7, 2016 6:57:44 PM (8 years ago)
Author:
rniwa@webkit.org
Message:

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:
Location:
trunk
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r202950 r202953  
     12016-07-07  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Replace scoped flag in Event by composed flag
     4        https://bugs.webkit.org/show_bug.cgi?id=158415
     5
     6        Reviewed by Chris Dumez.
     7
     8        Updated the tests to reflect the rename of scoped to composed and the negation of its semantics.
     9        Now every Event is assumed to be scoped / non-composed by default, and we need to explicitly set
     10        composed to true in order for events to cross shadow boundaries.
     11
     12        Also, every Event behaves as if related target is assumed to be scoped in the old terminology
     13        althoug the flag no longer exists.
     14
     15        * fast/shadow-dom/Extensions-to-Event-Interface-expected.txt:
     16        * fast/shadow-dom/Extensions-to-Event-Interface.html: Removed a test case that was testing
     17        relatedTargetScoped to false since this flag no longer exists.
     18        * fast/shadow-dom/MouseEvent-prototype-offsetX-offsetY.html:
     19        * fast/shadow-dom/event-inside-shadow-tree.html:
     20        * fast/shadow-dom/event-inside-slotted-node.html:
     21        * fast/shadow-dom/event-with-related-target.html:
     22        * fast/shadow-dom/trusted-event-scoped-flags-expected.txt:
     23        * fast/shadow-dom/trusted-event-scoped-flags.html:
     24        * fast/xmlhttprequest/xmlhttprequest-get-expected.txt:
     25        * http/tests/workers/worker-importScriptsOnError-expected.txt:
     26        * inspector/model/remote-object-get-properties-expected.txt:
     27
    1282016-07-07  Dean Jackson  <dino@apple.com>
    229

  • trunk/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface-expected.txt

    r200580 r202953  
    33PASS composedPath() must return an empty array when the event has not been dispatched
    44PASS composedPath() must return an empty array when the event is no longer dispatched
    5 PASS scoped must exist on Event
    6 PASS scoped on EventInit must default to false
    7 PASS scoped on EventInit must set the scoped flag
    8 PASS relatedTargetScoped must exist on Event
    9 PASS relatedTargetScoped on EventInit must default to false
    10 PASS relatedTargetScoped on EventInit must set the scoped flag
    11 PASS The event must propagate out of open mode shadow boundaries when the scoped flag is unset
    12 PASS The event must propagate out of closed mode shadow boundaries when the scoped flag is unset
    13 PASS The event must not propagate out of open mode shadow boundaries when the scoped flag is set
    14 PASS The event must not propagate out of closed mode shadow boundaries when the scoped flag is set
    15 PASS The event must propagate out of open mode shadow boundaries when the scoped flag is unset on an event with relatedTarget
    16 PASS The event must propagate out of closed mode shadow boundaries when the scoped flag is unset on an event with relatedTarget
    17 PASS The event must not propagate out of open mode shadow boundaries when the scoped flag is set on an event with relatedTarget
    18 PASS The event must not propagate out of closed mode shadow boundaries when the scoped flag is set on an event with relatedTarget
     5PASS composed must exist on Event
     6PASS composed on EventInit must default to false
     7PASS composed on EventInit must set the composed flag
     8PASS The event must propagate out of open mode shadow boundaries when the composed flag is set
     9PASS The event must propagate out of closed mode shadow boundaries when the composed flag is set
     10PASS The event must not propagate out of open mode shadow boundaries when the composed flag is unset
     11PASS The event must not propagate out of closed mode shadow boundaries when the composed flag is unset
     12PASS The event must not propagate out of open mode shadow boundaries when the composed flag is unset on an event with relatedTarget
     13PASS The event must not propagate out of closed mode shadow boundaries when the composed flag is unset on an event with relatedTarget
    1914PASS 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
    2015PASS 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

  • trunk/LayoutTests/fast/shadow-dom/Extensions-to-Event-Interface.html

    r200580 r202953  
    3232
    3333test(function () {
    34     assert_true('scoped' in Event.prototype);
    35     assert_true('scoped' in new Event('my-event'));
    36 }, 'scoped must exist on Event');
     34    assert_true('composed' in Event.prototype);
     35    assert_true('composed' in new Event('my-event'));
     36}, 'composed must exist on Event');
    3737
    3838test(function () {
    3939    var event = new Event('my-event');
    40     assert_false(event.scoped);
    41 }, 'scoped on EventInit must default to false');
    42 
    43 test(function () {
    44     var event = new Event('my-event', {scoped: true});
    45     assert_true(event.scoped);
    46 
    47     event = new Event('my-event', {scoped: false});
    48     assert_false(event.scoped);
    49 }, 'scoped on EventInit must set the scoped flag');
    50 
    51 test(function () {
    52     assert_true('relatedTargetScoped' in Event.prototype);
    53     assert_true('relatedTargetScoped' in new Event('my-event'));
    54 }, 'relatedTargetScoped must exist on Event');
    55 
    56 test(function () {
    57     var event = new Event('my-event');
    58     assert_false(event.relatedTargetScoped);
    59 }, 'relatedTargetScoped on EventInit must default to false');
    60 
    61 test(function () {
    62     var event = new Event('my-event', {relatedTargetScoped: true});
    63     assert_true(event.relatedTargetScoped);
    64 
    65     event = new Event('my-event', {relatedTargetScoped: false});
    66     assert_false(event.relatedTargetScoped);
    67 }, 'relatedTargetScoped on EventInit must set the scoped flag');
     40    assert_false(event.composed);
     41}, 'composed on EventInit must default to false');
     42
     43test(function () {
     44    var event = new Event('my-event', {composed: true});
     45    assert_true(event.composed);
     46
     47    event = new Event('my-event', {composed: false});
     48    assert_false(event.composed);
     49}, 'composed on EventInit must set the composed flag');
    6850
    6951/*
    … …  
    7759*/
    7860
    79 function testUnscopedEvent(mode) {
    80     test(function () {
    81         var nodes = createTestTree(mode);
    82         var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {scoped: false, bubbles: true}));
     61function testComposedEvent(mode) {
     62    test(function () {
     63        var nodes = createTestTree(mode);
     64        var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {composed: true, bubbles: true}));
    8365
    8466        var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR', 'A'];
    … …  
    8971        assert_array_equals(log.pathAtTargets[2], mode == 'open' ? expectedPath : ['A1', 'A-SR', 'A'],
    9072            'composedPath must only contain unclosed nodes of the current target.');
    91     }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is unset');
    92 }
    93 
    94 testUnscopedEvent('open');
    95 testUnscopedEvent('closed');
     73    }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the composed flag is set');
     74}
     75
     76testComposedEvent('open');
     77testComposedEvent('closed');
    9678
    9779/*
    … …  
    10587*/
    10688
    107 function testScopedEvent(mode) {
    108     test(function () {
    109         var nodes = createTestTree(mode);
    110         var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {scoped: true, bubbles: true}));
     89function testNonComposedEvent(mode) {
     90    test(function () {
     91        var nodes = createTestTree(mode);
     92        var log = dispatchEventWithLog(nodes, nodes.A1a, new Event('my-event', {composed: false, bubbles: true}));
    11193
    11294        var expectedPath = ['A1a', 'A1-SR'];
    … …  
    11597        assert_array_equals(log.pathAtTargets[0], expectedPath);
    11698        assert_array_equals(log.pathAtTargets[1], expectedPath);
    117     }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is set');
    118 }
    119 
    120 testScopedEvent('open');
    121 testScopedEvent('closed');
    122 
    123 /*
    124 -SR: ShadowRoot  -S: Slot  target: (~)  relatedTarget: [~]  *: indicates start  digit: event path order
    125 A (4) [4] ----------------------- A-SR (3)
    126 + B ------------ B-SR             + A1 (2) ------- A1-SR (1)
    127   + C            + B1 --- B1-SR   + A2-S [*; 0-3]  + A1a (*; 0)
    128   + D --- D-SR     + B1a  + B1b --- B1b-SR
    129           + D1            + B1c-S   + B1b1
    130                                     + B1b2
    131 */
    132 
    133 function testUnscopedEventWithUnscopedRelatedTarget(mode) {
    134     test(function () {
    135         var nodes = createTestTree(mode);
    136         var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: false, bubbles: true, relatedTarget: nodes['A2-S']}));
    137 
    138         var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR', 'A'];
    139         var pathExposedToA1 = ['A1', 'A-SR', 'A'];
    140         var pathExposedToA = ['A'];
    141         assert_array_equals(log.eventPath, expectedPath);
    142         assert_array_equals(log.eventPath.length, log.pathAtTargets.length);
    143         assert_array_equals(log.pathAtTargets[0], expectedPath);
    144         assert_array_equals(log.pathAtTargets[1], expectedPath);
    145         assert_array_equals(log.pathAtTargets[2], mode == 'open' ? expectedPath : pathExposedToA1);
    146         assert_array_equals(log.pathAtTargets[3], mode == 'open' ? expectedPath : pathExposedToA1);
    147         assert_array_equals(log.pathAtTargets[4], mode == 'open' ? expectedPath : pathExposedToA);
    148         assert_array_equals(log.relatedTargets, ['A2-S', 'A2-S', 'A2-S', 'A2-S', 'A']);
    149     }, 'The event must propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is unset on an event with relatedTarget');
    150 }
    151 
    152 testUnscopedEventWithUnscopedRelatedTarget('open');
    153 testUnscopedEventWithUnscopedRelatedTarget('closed');
     99    }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the composed flag is unset');
     100}
     101
     102testNonComposedEvent('open');
     103testNonComposedEvent('closed');
    154104
    155105/*
    … …  
    163113*/
    164114
    165 function testScopedEventWithUnscopedRelatedTarget(mode) {
    166     test(function () {
    167         var nodes = createTestTree(mode);
    168         var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: true, relatedTargetScoped: false, bubbles: true, relatedTarget: nodes['A2-S']}));
     115function testNonComposedEventWithRelatedTarget(mode) {
     116    test(function () {
     117        var nodes = createTestTree(mode);
     118        var log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {composed: false, bubbles: true, relatedTarget: nodes['A2-S']}));
    169119
    170120        var expectedPath = ['A1a', 'A1-SR'];
    … …  
    174124        assert_array_equals(log.pathAtTargets[1], expectedPath);
    175125        assert_array_equals(log.relatedTargets, ['A2-S', 'A2-S']);
    176     }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the scoped flag is set on an event with relatedTarget');
    177 }
    178 
    179 testScopedEventWithUnscopedRelatedTarget('open');
    180 testScopedEventWithUnscopedRelatedTarget('closed');
     126    }, 'The event must not propagate out of ' + mode + ' mode shadow boundaries when the composed flag is unset on an event with relatedTarget');
     127}
     128
     129testNonComposedEventWithRelatedTarget('open');
     130testNonComposedEventWithRelatedTarget('closed');
    181131
    182132/*
    … …  
    221171*/
    222172
    223 function testUnscopedEventWithScopedRelatedTarget(mode) {
    224     test(function () {
    225         var nodes = createTestTree(mode);
    226         log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: true, bubbles: true, relatedTarget: nodes['A2-S']}));
     173function testComposedEventWithRelatedTarget(mode) {
     174    test(function () {
     175        var nodes = createTestTree(mode);
     176        log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {composed: true, bubbles: true, relatedTarget: nodes['A2-S']}));
    227177
    228178        var expectedPath = ['A1a', 'A1-SR', 'A1', 'A-SR'];
    … …  
    238188}
    239189
    240 testUnscopedEventWithScopedRelatedTarget('open');
    241 testUnscopedEventWithScopedRelatedTarget('closed');
     190testComposedEventWithRelatedTarget('open');
     191testComposedEventWithRelatedTarget('closed');
    242192
    243193/*
    … …  
    251201*/
    252202
    253 function testUnscopedEventWithScopedRelatedTargetThroughSlot(mode) {
    254     test(function () {
    255         var nodes = createTestTree(mode);
    256         log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {scoped: false, relatedTargetScoped: true, bubbles: true, relatedTarget: nodes.A1a}));
     203function testComposedEventThroughSlot(mode) {
     204    test(function () {
     205        var nodes = createTestTree(mode);
     206        log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {composed: true, bubbles: true, relatedTarget: nodes.A1a}));
    257207
    258208        var expectedPath =          ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'];
    … …  
    278228}
    279229
    280 testUnscopedEventWithScopedRelatedTargetThroughSlot('open');
    281 testUnscopedEventWithScopedRelatedTargetThroughSlot('closed');
     230testComposedEventThroughSlot('open');
     231testComposedEventThroughSlot('closed');
    282232
    283233</script>

  • trunk/LayoutTests/fast/shadow-dom/MouseEvent-prototype-offsetX-offsetY.html

    r200536 r202953  
    4242
    4343    var eventLogs = attachLoggers([target, container, host, document.body]);
    44     var mouseEvent = new MouseEvent('mousedown', {clientX: 51, clientY: 37, scoped: false, bubbles: true});
     44    var mouseEvent = new MouseEvent('mousedown', {clientX: 51, clientY: 37, composed: true, bubbles: true});
    4545    target.dispatchEvent(mouseEvent);
    4646
    … …  
    7979
    8080    var eventLogs = attachLoggers([target, container, shadowRoot, host, document.body]);
    81     var mouseEvent = new MouseEvent('mousedown', {clientX: 51, clientY: 37, scoped: false, bubbles: true});
     81    var mouseEvent = new MouseEvent('mousedown', {clientX: 51, clientY: 37, composed: true, bubbles: true});
    8282    target.dispatchEvent(mouseEvent);
    8383

  • trunk/LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html

    r190214 r202953  
    4444        var shadow = createShadowRootWithGrandChild(mode);
    4545
    46         log = dispatchEventWithLog(shadow.target, new Event('foo', {bubbles: true}));
     46        log = dispatchEventWithLog(shadow.target, new Event('foo', {composed: true, bubbles: true}));
    4747
    4848        assert_array_equals(log.length, 4, 'EventPath must contain [target, parent, shadow root, shadow host]');
    … …  
    6363        document.body.appendChild(shadow.host);
    6464
    65         log = dispatchEventWithLog(shadow.target, new Event('foo', {bubbles: true}));
     65        log = dispatchEventWithLog(shadow.target, new Event('foo', {composed: true, bubbles: true}));
    6666
    6767        assert_array_equals(log.length, 7, 'EventPath must contain [target, parent, shadow root, shadow host, body, html, document]');
    … …  
    101101        var shadow = createNestedShadowRoot(innerMode, outerMode);
    102102
    103         log = dispatchEventWithLog(shadow.target, new Event('bar', {bubbles: true}));
     103        log = dispatchEventWithLog(shadow.target, new Event('bar', {composed: true, bubbles: true}));
    104104
    105105        assert_array_equals(log.length, 6, 'EventPath must contain [target, inner root, inner host, parent, outer root, outer host]');
    … …  
    124124        document.body.appendChild(shadow.outerHost);
    125125
    126         log = dispatchEventWithLog(shadow.target, new Event('bar', {bubbles: true}));
     126        log = dispatchEventWithLog(shadow.target, new Event('bar', {composed: true, bubbles: true}));
    127127
    128128        assert_array_equals(log.length, 6, 'EventPath must contain [target, inner root, inner host, parent, outer root, outer host]');

  • trunk/LayoutTests/fast/shadow-dom/event-inside-slotted-node.html

    r200464 r202953  
    7676                var shadow = createShadowHostWithAssignedGrandChild(mode);
    7777
    78                 log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true}));
     78                log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true}));
    7979
    8080                assert_equals(log.length, 6, 'EventPath must contain [target, target parent, slot, slot parent, shadow root, shadow host]');
    … …  
    9797                document.body.appendChild(shadow.host);
    9898
    99                 log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true}));
     99                log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true}));
    100100
    101101                assert_equals(log.length, 9, 'EventPath must contain [target, target parent, slot, slot parent, shadow root, shadow host, body, html, document]');
    … …  
    175175                var shadow = createNestedShadowTreesWithSlots(innerMode, outerUpperMode, outerLowerMode);
    176176
    177                 log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true}));
     177                log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true}));
    178178
    179179                assert_equals(log.length, 15, 'EventPath must contain 15 targets');
    … …  
    225225                shadow.target = shadow.innerSlot;
    226226
    227                 log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true}));
     227                log = dispatchEventWithLog(shadow, new Event('foo', {bubbles: true, composed: true}));
    228228
    229229                assert_equals(log.length, 12, 'EventPath must contain 12 targets');

  • trunk/LayoutTests/fast/shadow-dom/event-with-related-target.html

    r198056 r202953  
    1717        /*
    1818        -SR: ShadowRoot  -S: Slot  target: (~)  relatedTarget: [~]  *: indicates start  digit: event path order
    19         A (8) --------------------------------------------- A-SR (7)
    20         + B (5) [5-8] --- B-SR (4)                          + A1 -------- A1-SR
    21           + C             + B1 (3) [*; 0-4] --- B1-SR (2)   + A2-S (6)    + A1a
    22           + D --- D-SR      + B1a (*; 0)        + B1b [1,2] --- B1b-SR
    23                   + D1                          + B1c-S (1)     + B1b1
    24                                                                 + B1b2
     19        A ----------------------------------------------- A-SR
     20        + B ----------- B-SR (4)                          + A1 --- A1-SR
     21          + C           + B1 (3) [*; 0-4] --- B1-SR (2)   + A2-S   + A1a
     22          + D --- D-SR    + B1a (*; 0)        + B1b [1,2] --- B1b-SR
     23                  + D1                        + B1c-S (1)     + B1b1
     24                                                              + B1b2
    2525        */
    2626        function testEventAtB1aWithB1a(mode) {
    … …  
    2828                var nodes = createTestTree(mode);
    2929
    30                 log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1}));
    31 
    32                 assert_array_equals(log.eventPath,
    33                     ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.');
    34                 assert_array_equals(log.relatedTargets,
    35                     ['B1',  'B1',    'B1',    'B1', 'B1',   'B', 'B',    'B',    'B'], 'The related targets must be correct.');
     30                log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1}));
     31
     32                assert_array_equals(log.eventPath,
     33                    ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.');
     34                assert_array_equals(log.relatedTargets,
     35                    ['B1',  'B1',    'B1',    'B1', 'B1'], 'The related targets must be correct.');
    3636
    3737            }, 'Firing an event at B1a with relatedNode at B1 with ' + mode + ' mode shadow trees');
    … …  
    4343        /*
    4444        -SR: ShadowRoot  -S: Slot  target: (~)  relatedTarget: [~]  *: indicates start  digit: event path order
    45         A (8) -------------------------------------------- A-SR (7)
    46         + B (5) [5-8] --- B-SR (4)                         + A1 ------ A1-SR
    47           + C             + B1 (3) [0,3-4] --- B1-SR (2)   + A2-S (6)  + A1a
    48           + D --- D-SR      + B1a (*; 0)       + B1b [1,2] --- B1b-SR
    49                   + D1                         + B1c-S (1)     + B1b1 [*]
    50                                                                + B1b2
     45        A ------------------------------------------------- A-SR
     46        + B ----------- B-SR (4)                            + A1 --- A1-SR
     47          + C           + B1 (3) [0,3-4] --- B1-SR (2)      + A2-S   + A1a
     48          + D --- D-SR    + B1a (*; 0)       + B1b [1,2] --- B1b-SR
     49                  + D1                       + B1c-S (1)     + B1b1 [*]
     50                                                             + B1b2
    5151        */
    5252        function testEventAtB1aWithB1b1(mode) {
    … …  
    5454                var nodes = createTestTree(mode);
    5555
    56                 log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1b1}));
    57 
    58                 assert_array_equals(log.eventPath,
    59                     ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.');
    60                 assert_array_equals(log.relatedTargets,
    61                     ['B1',  'B1b',   'B1b',   'B1', 'B1',   'B', 'B',    'B',    'B'], 'The related targets must be correct.');
     56                log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1b1}));
     57
     58                assert_array_equals(log.eventPath,
     59                    ['B1a', 'B1c-S', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.');
     60                assert_array_equals(log.relatedTargets,
     61                    ['B1',  'B1b',   'B1b',   'B1', 'B1'], 'The related targets must be correct.');
    6262
    6363            }, 'Firing an event at B1a with relatedNode at B1b1 with ' + mode + ' mode shadow trees');
    … …  
    6969        /*
    7070        -SR: ShadowRoot  -S: Slot  target: (~)  relatedTarget: [~]  *: indicates start  digit: event path order
    71         A (9) ------------------------------------------------------- A-SR (8)
    72         + B (6) [6-9] --- B-SR (5)                                    + A1 ------ A1-SR
    73           + C             + B1 (4) --------- B1-SR (3)                + A2-S (7)  + A1a
    74           + D --- D-SR      + B1a [*; 0-5]   + B1b (2) --- B1b-SR (1)
    75                   + D1                       + B1c-S       + B1b1 (*; 0)
    76                                                            + B1b2
     71        A -------------------------------------------------- A-SR
     72        + B ------------- B-SR (5)                           + A1 --- A1-SR
     73          + C             + B1 (4) ------- B1-SR (3)         + A2-S   + A1a
     74          + D --- D-SR    + B1a [*; 0-5]   + B1b (2) --- B1b-SR (1)
     75                  + D1                     + B1c-S       + B1b1 (*; 0)
     76                                                         + B1b2
    7777        */
    7878        function testEventAtB1b1WithB1a(mode) {
    … …  
    8080                var nodes = createTestTree(mode);
    8181
    82                 log = dispatchEventWithLog(nodes, nodes.B1b1, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a}));
    83 
    84                 assert_array_equals(log.eventPath,
    85                     ['B1b1', 'B1b-SR', 'B1b', 'B1-SR', 'B1', 'B-SR', 'B', 'A2-S', 'A-SR', 'A'], 'The event path must be correct.');
    86                 assert_array_equals(log.relatedTargets,
    87                     ['B1a',  'B1a',    'B1a', 'B1a',   'B1a', 'B1a', 'B', 'B',    'B',    'B'], 'The related targets must be correct.');
     82                log = dispatchEventWithLog(nodes, nodes.B1b1, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a}));
     83
     84                assert_array_equals(log.eventPath,
     85                    ['B1b1', 'B1b-SR', 'B1b', 'B1-SR', 'B1', 'B-SR'], 'The event path must be correct.');
     86                assert_array_equals(log.relatedTargets,
     87                    ['B1a',  'B1a',    'B1a', 'B1a',   'B1a', 'B1a'], 'The related targets must be correct.');
    8888
    8989            }, 'Firing an event at B1b1 with relatedNode at B1a with ' + mode + ' mode shadow trees');
    … …  
    106106                var nodes = createTestTree(mode);
    107107
    108                 log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.D1}));
     108                log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.D1}));
    109109
    110110                assert_array_equals(log.eventPath,
    … …  
    132132                var nodes = createTestTree(mode);
    133133
    134                 log = dispatchEventWithLog(nodes, nodes.D1, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a}));
     134                log = dispatchEventWithLog(nodes, nodes.D1, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a}));
    135135
    136136                assert_array_equals(log.eventPath,
    … …  
    158158                var nodes = createTestTree(mode);
    159159
    160                 log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.A1a}));
     160                log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.A1a}));
    161161
    162162                assert_array_equals(log.eventPath,
    … …  
    184184                var nodes = createTestTree(mode);
    185185
    186                 log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a}));
     186                log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a}));
    187187
    188188                assert_array_equals(log.eventPath,
    … …  
    213213
    214214                nodes['A-SR'].removeChild(nodes.A1);
    215                 log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.A1a}));
     215                log = dispatchEventWithLog(nodes, nodes.B1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.A1a}));
    216216
    217217                assert_array_equals(log.eventPath,
    … …  
    242242
    243243                nodes['A-SR'].removeChild(nodes.A1);
    244                 log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, relatedTarget: nodes.B1a}));
     244                log = dispatchEventWithLog(nodes, nodes.A1a, new MouseEvent('foo', {bubbles: true, composed: true, relatedTarget: nodes.B1a}));
    245245
    246246                assert_array_equals(log.eventPath,      ['A1a', 'A1-SR', 'A1'], 'The event path must be correct.');

  • trunk/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags-expected.txt

    r198056 r202953  
    22world
    33PASS input.type = "radio"; log(input, "change"); input.click(); eventType is "change"
    4 PASS scoped is true
    5 PASS relatedTargetScoped is false
     4PASS composed is false
    65
    76PASS log(form, "reset"); form.reset(); eventType is "reset"
    8 PASS scoped is true
    9 PASS relatedTargetScoped is false
     7PASS composed is false
    108
    119PASS form.focus(); log(input, "focus"); input.focus(); eventType is "focus"
    12 PASS scoped is false
    13 PASS relatedTargetScoped is true
     10PASS composed is true
    1411
    1512PASS log(input, "blur"); form.focus(); eventType is "blur"
    16 PASS scoped is false
    17 PASS relatedTargetScoped is true
     13PASS composed is true
    1814
    1915PASS input.type = "text"; log(input, "mousemove"); eventSender.mouseMoveTo(x, y); eventType is "mousemove"
    20 PASS scoped is false
    21 PASS relatedTargetScoped is false
     16PASS composed is true
    2217
    2318PASS log(input, "mousedown"); eventSender.mouseDown(); eventType is "mousedown"
    24 PASS scoped is false
    25 PASS relatedTargetScoped is false
     19PASS composed is true
    2620
    2721PASS log(input, "mouseup"); eventSender.mouseUp(); eventType is "mouseup"
    28 PASS scoped is false
    29 PASS relatedTargetScoped is false
     22PASS composed is true
    3023
    3124PASS log(input, "mouseout"); eventSender.mouseMoveTo(0, 0); eventType is "mouseout"
    32 PASS scoped is false
    33 PASS relatedTargetScoped is true
     25PASS composed is true
    3426
    3527PASS log(input, "mouseover"); eventSender.mouseMoveTo(x, y); eventType is "mouseover"
    36 PASS scoped is false
    37 PASS relatedTargetScoped is true
     28PASS composed is true
    3829
    3930input.value = "hello"; eventSender.mouseMoveTo(input.offsetLeft + 1, y); eventSender.mouseDown();
    4031PASS log(input, "select"); eventSender.mouseMoveTo(input.offsetLeft + input.offsetWidth - 2, y); eventSender.mouseUp(); eventType is "select"
    41 PASS scoped is true
    42 PASS relatedTargetScoped is false
     32PASS composed is false
    4333
    4434PASS log(editableElement, "selectstart"); eventSender.mouseMoveTo(editableElement.offsetLeft + 1, y); eventSender.mouseDown(); eventType is "selectstart"
    45 PASS scoped is true
    46 PASS relatedTargetScoped is false
     35PASS composed is false
    4736
    4837PASS eventType is "load"
    49 PASS scoped is true
    50 PASS relatedTargetScoped is false
     38PASS composed is false
    5139
    5240PASS eventType is "error"
    53 PASS scoped is true
    54 PASS relatedTargetScoped is false
     41PASS composed is false
    5542
    5643PASS eventType is "scroll"
    57 PASS scoped is true
    58 PASS relatedTargetScoped is false
     44PASS composed is false
    5945
    6046PASS eventType is "resize"
    61 PASS scoped is true
    62 PASS relatedTargetScoped is false
     47PASS composed is false
    6348
    6449PASS successfullyParsed is true

  • trunk/LayoutTests/fast/shadow-dom/trusted-event-scoped-flags.html

    r198056 r202953  
    99
    1010var eventType;
    11 var scoped;
    12 var relatedTargetScoped;
     11var composed;
    1312
    1413function logEvent(event) {
    1514    eventType = event.type;
    16     scoped = event.scoped;
    17     relatedTargetScoped = event.relatedTargetScoped;
     15    composed = event.composed;
    1816}
    1917
    2018function checkFlags(code, expected) {
    2119    shouldBeEqualToString(code ? code + '; eventType' : 'eventType', expected.eventType);
    22     shouldBe('scoped', expected.scoped.toString());
    23     shouldBe('relatedTargetScoped', expected.relatedTargetScoped.toString());
     20    shouldBe('composed', expected.composed.toString());
    2421    debug('');
    2522}
    … …  
    2926function log(target, eventName) {
    3027    eventType = undefined;
    31     scoped = undefined;
    32     relatedTargetScoped = undefined;
     28    composed = undefined;
    3329    if (lastTarget)
    3430        lastTarget.removeEventListener(lastEventName, logEvent);
    … …  
    4238form.tabIndex = 0;
    4339
    44 checkFlags('input.type = "radio"; log(input, "change"); input.click()', {eventType: 'change', scoped: true, relatedTargetScoped: false});
    45 checkFlags('log(form, "reset"); form.reset()', {eventType: 'reset', scoped: true, relatedTargetScoped: false});
     40checkFlags('input.type = "radio"; log(input, "change"); input.click()', {eventType: 'change', composed: false});
     41checkFlags('log(form, "reset"); form.reset()', {eventType: 'reset', composed: false});
    4642
    47 checkFlags('form.focus(); log(input, "focus"); input.focus()', {eventType: 'focus', scoped: false, relatedTargetScoped: true});
    48 checkFlags('log(input, "blur"); form.focus()', {eventType: 'blur', scoped: false, relatedTargetScoped: true});
     43checkFlags('form.focus(); log(input, "focus"); input.focus()', {eventType: 'focus', composed: true});
     44checkFlags('log(input, "blur"); form.focus()', {eventType: 'blur', composed: true});
    4945
    5046if (!window.eventSender)
    … …  
    5854    var y = input.offsetTop + input.offsetHeight / 2;
    5955
    60     checkFlags('input.type = "text"; log(input, "mousemove"); eventSender.mouseMoveTo(x, y)', {eventType: 'mousemove', scoped: false, relatedTargetScoped: false});
    61     checkFlags('log(input, "mousedown"); eventSender.mouseDown()', {eventType: 'mousedown', scoped: false, relatedTargetScoped: false});
    62     checkFlags('log(input, "mouseup"); eventSender.mouseUp()', {eventType: 'mouseup', scoped: false, relatedTargetScoped: false});
    63     checkFlags('log(input, "mouseout"); eventSender.mouseMoveTo(0, 0)', {eventType: 'mouseout', scoped: false, relatedTargetScoped: true});
    64     checkFlags('log(input, "mouseover"); eventSender.mouseMoveTo(x, y)', {eventType: 'mouseover', scoped: false, relatedTargetScoped: true});
     56    checkFlags('input.type = "text"; log(input, "mousemove"); eventSender.mouseMoveTo(x, y)', {eventType: 'mousemove', composed: true});
     57    checkFlags('log(input, "mousedown"); eventSender.mouseDown()', {eventType: 'mousedown', composed: true});
     58    checkFlags('log(input, "mouseup"); eventSender.mouseUp()', {eventType: 'mouseup', composed: true});
     59    checkFlags('log(input, "mouseout"); eventSender.mouseMoveTo(0, 0)', {eventType: 'mouseout', composed: true});
     60    checkFlags('log(input, "mouseover"); eventSender.mouseMoveTo(x, y)', {eventType: 'mouseover', composed: true});
    6561
    6662    evalAndLog('input.value = "hello"; eventSender.mouseMoveTo(input.offsetLeft + 1, y); eventSender.mouseDown();');
    6763    checkFlags('log(input, "select"); eventSender.mouseMoveTo(input.offsetLeft + input.offsetWidth - 2, y); eventSender.mouseUp()',
    68         {eventType: 'select', scoped: true, relatedTargetScoped: false});
     64        {eventType: 'select', composed: false});
    6965
    7066    var editableElement = document.getElementById('editor');
    7167    y = editableElement.offsetTop + editableElement.offsetHeight / 2;
    7268    checkFlags('log(editableElement, "selectstart"); eventSender.mouseMoveTo(editableElement.offsetLeft + 1, y); eventSender.mouseDown()',
    73         {eventType: 'selectstart', scoped: true, relatedTargetScoped: false});
     69        {eventType: 'selectstart', composed: false});
    7470}
    7571
    … …  
    7975    scriptThatLoads.onload = function (event) {
    8076        logEvent(event);
    81         checkFlags('', {eventType: 'load', scoped: true, relatedTargetScoped: false});
     77        checkFlags('', {eventType: 'load', composed: false});
    8278        testErrorEvent();
    8379    }
    … …  
    9086    scriptThatFailsToLoad.onerror = function (event) {
    9187        logEvent(event);
    92         checkFlags('', {eventType: 'error', scoped: true, relatedTargetScoped: false});
     88        checkFlags('', {eventType: 'error', composed: false});
    9389        testScrollEvent();
    9490    }
    … …  
    10298        window.scrollTo(0, 1000);
    10399        setTimeout(function () {
    104             checkFlags('', {eventType: 'scroll', scoped: true, relatedTargetScoped: false});
     100            checkFlags('', {eventType: 'scroll', composed: false});
    105101            window.scrollTo(0, 0);
    106102            testResizeEvent();
    … …  
    122118            iframe.contentDocument.body.getBoundingClientRect();
    123119            setTimeout(function () {
    124                 checkFlags('', {eventType: 'resize', scoped: true, relatedTargetScoped: false});
     120                checkFlags('', {eventType: 'resize', composed: false});
    125121                finishJSTest();
    126122            }, 0);

  • trunk/LayoutTests/fast/xmlhttprequest/xmlhttprequest-get-expected.txt

    r200585 r202953  
    4848cancelable : 'false'
    4949clipboardData : 'undefined'
     50composed : 'false'
    5051composedPath : 'function composedPath() {
    5152    [native code]
    … …  
    6465    [native code]
    6566}'
    66 relatedTargetScoped : 'false'
    6767returnValue : 'true'
    68 scoped : 'true'
    6968srcElement : '[object XMLHttpRequest]'
    7069stopImmediatePropagation : 'function stopImmediatePropagation() {

  • trunk/LayoutTests/http/tests/workers/worker-importScriptsOnError-expected.txt

    r202023 r202953  
    2828clipboardData: undefined,
    2929colno: 14,
     30composed: false,
    3031composedPath: function composedPath() { [native code] },
    3132currentTarget: [object Worker],
    … …  
    3940message: Error: Script error.,
    4041preventDefault: function preventDefault() { [native code] },
    41 relatedTargetScoped: false,
    4242returnValue: true,
    43 scoped: true,
    4443srcElement: [object Worker],
    4544stopImmediatePropagation: function stopImmediatePropagation() { [native code] },

  • trunk/LayoutTests/inspector/model/remote-object-get-properties-expected.txt

    r202568 r202953  
    4949    bubbles
    5050    cancelable
    51     scoped
    52     relatedTargetScoped
     51    composed
    5352    timeStamp
    5453    defaultPrevented
    … …  
    6867    bubbles
    6968    cancelable
    70     scoped
    71     relatedTargetScoped
     69    composed
    7270    timeStamp
    7371    defaultPrevented

  • trunk/Source/WebCore/ChangeLog

    r202952 r202953  
     12016-07-07  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Replace scoped flag in Event by composed flag
     4        https://bugs.webkit.org/show_bug.cgi?id=158415
     5
     6        Reviewed by Chris Dumez.
     7
     8        Replace `scoped` flag with `composed` flag and negate its meaning per the latest spec:
     9        https://dom.spec.whatwg.org/#dom-event-composed
     10        https://github.com/w3c/webcomponents/issues/513
     11
     12        In the old spec, every event was assumed to be "composed" (crosses shadow boundaries)
     13        by default and there was `scoped` flag which prevented the event from crossing bondaries,
     14        and there was a handful of events for which `scoped` was set true when dispatched by UA.
     15
     16        In the new spec, every event is assumed to be "scoped" and a handful of user-initiated
     17        events set `composed` flag to true, which is also exposed in EventInit dictionary.
     18        `relatedTargetScoped` flag has been removed. New behavior is identical to when this flag
     19        was set to true.
     20
     21        No new tests since existing tests are updated to test the new flag and behavior.
     22
     23        * dom/CompositionEvent.cpp:
     24        (WebCore::CompositionEvent::isCompositionEvent): Added.
     25        * dom/CompositionEvent.h:
     26        * dom/Event.cpp:
     27        (WebCore::Event::Event): Initialize m_composed. Also re-ordered m_type and m_isInitialized
     28        for better packing.
     29        (WebCore::Event::composed): Renamed from Event::composed. We return true whenever composed
     30        is set to true in EventInit, or the engine is dispatching an user-initiated event listed in:
     31        https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937
     32        as well as keypress, cut, paste, and, copy as discussed in:
     33        https://github.com/w3c/webcomponents/issues/513#issuecomment-230988170
     34        (WebCore::Event::isCompositionEvent): Added.
     35        * dom/Event.h:
     36        (WebCore::Event::composed): Added.
     37        (WebCore::Event::scoped): Deleted.
     38        (WebCore::Event::relatedTargetScoped): Deleted.
     39        (WebCore::Event): Reordered m_type and m_isInitialized for better packing. Added m_composed
     40        and removed m_scoped and m_relatedTargetScoped.
     41        * dom/Event.idl:
     42        * dom/EventPath.cpp:
     43        (WebCore::shouldEventCrossShadowBoundary): Returns true if the event did not originate from
     44        a shadow tree (this event entered the current shadow tree via a slot so we need to proceed with
     45        the normal bubble path outside the shadow tree) or composed flag is set true.
     46        (WebCore::EventPath::EventPath): m_event no longer exists, which was only used to get the value
     47        of relatedTargetScoped which has been removed.
     48        (WebCore::EventPath::setRelatedTarget): Behave as if relatedTargetScoped is always set true
     49        since the flag has been removed.
     50        * dom/EventPath.h:
     51        * dom/FocusEvent.cpp:
     52        (WebCore::FocusEvent::relatedTargetScoped): Deleted.
     53        * dom/FocusEvent.h:
     54        * dom/MouseEvent.cpp:
     55        (WebCore::MouseEvent::relatedTargetScoped): Deleted.
     56        * dom/MouseEvent.h:
     57
    1582016-07-07  Chris Dumez  <cdumez@apple.com>
    259

  • trunk/Source/WebCore/dom/CompositionEvent.cpp

    r196400 r202953  
    6767}
    6868
     69bool CompositionEvent::isCompositionEvent() const
     70{
     71    return true;
     72}
     73
    6974} // namespace WebCore

  • trunk/Source/WebCore/dom/CompositionEvent.h

    r197563 r202953  
    6666    CompositionEvent(const AtomicString& type, const CompositionEventInit&);
    6767
     68    bool isCompositionEvent() const override;
     69
    6870    String m_data;
    6971};

  • trunk/Source/WebCore/dom/Event.cpp

    r202105 r202953  
    3838
    3939Event::Event(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
    40     : m_isInitialized(true)
    41     , m_type(eventType)
     40    : m_type(eventType)
     41    , m_isInitialized(true)
    4242    , m_canBubble(canBubbleArg)
    4343    , m_cancelable(cancelableArg)
    … …  
    4848
    4949Event::Event(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg, double timestamp)
    50     : m_isInitialized(true)
    51     , m_type(eventType)
     50    : m_type(eventType)
     51    , m_isInitialized(true)
    5252    , m_canBubble(canBubbleArg)
    5353    , m_cancelable(cancelableArg)
    … …  
    5858
    5959Event::Event(const AtomicString& eventType, const EventInit& initializer)
    60     : m_isInitialized(true)
    61     , m_type(eventType)
     60    : m_type(eventType)
     61    , m_isInitialized(true)
    6262    , m_canBubble(initializer.bubbles)
    6363    , m_cancelable(initializer.cancelable)
    64     , m_scoped(initializer.scoped)
    65     , m_relatedTargetScoped(initializer.relatedTargetScoped)
     64    , m_composed(initializer.composed)
    6665    , m_createTime(convertSecondsToDOMTimeStamp(currentTime()))
    6766{
    … …  
    8887}
    8988
    90 bool Event::scoped() const
    91 {
    92     if (m_scoped)
     89bool Event::composed() const
     90{
     91    if (m_composed)
    9392        return true;
    9493
    … …  
    9796        return false;
    9897
    99     return m_type == eventNames().abortEvent
    100         || m_type == eventNames().changeEvent
    101         || m_type == eventNames().errorEvent
    102         || m_type == eventNames().loadEvent
    103         || m_type == eventNames().resetEvent
    104         || m_type == eventNames().resizeEvent
    105         || m_type == eventNames().scrollEvent
    106         || m_type == eventNames().selectEvent
    107         || m_type == eventNames().selectstartEvent
    108         || m_type == eventNames().slotchangeEvent;
     98    return m_type == eventNames().inputEvent
     99        || m_type == eventNames().textInputEvent
     100        || isCompositionEvent()
     101        || isClipboardEvent()
     102        || isFocusEvent()
     103        || isKeyboardEvent()
     104        || isMouseEvent()
     105        || isTouchEvent();
    109106}
    110107
    … …  
    130127
    131128bool Event::isKeyboardEvent() const
     129{
     130    return false;
     131}
     132
     133bool Event::isCompositionEvent() const
    132134{
    133135    return false;

  • trunk/Source/WebCore/dom/Event.h

    r201757 r202953  
    4444    bool bubbles { false };
    4545    bool cancelable { false };
    46     bool scoped { false };
    47     bool relatedTargetScoped { false };
     46    bool composed { false };
    4847};
    4948
    … …  
    118117    bool bubbles() const { return m_canBubble; }
    119118    bool cancelable() const { return m_cancelable; }
    120     bool scoped() const;
    121     virtual bool relatedTargetScoped() const { return m_relatedTargetScoped; }
     119    bool composed() const;
    122120
    123121    DOMTimeStamp timeStamp() const { return m_createTime; }
    … …  
    148146    virtual bool isFocusEvent() const;
    149147    virtual bool isKeyboardEvent() const;
     148    virtual bool isCompositionEvent() const;
    150149    virtual bool isTouchEvent() const;
    151150
    … …  
    207206
    208207private:
     208    AtomicString m_type;
     209
    209210    bool m_isInitialized { false };
    210     AtomicString m_type;
    211211    bool m_canBubble { false };
    212212    bool m_cancelable { false };
    213     bool m_scoped { false };
    214     bool m_relatedTargetScoped { false };
     213    bool m_composed { false };
    215214
    216215    bool m_propagationStopped { false };

  • trunk/Source/WebCore/dom/Event.idl

    r202091 r202953  
    5959    [InitializedByEventConstructor] readonly attribute boolean bubbles;
    6060    [InitializedByEventConstructor] readonly attribute boolean cancelable;
    61     [InitializedByEventConstructor, EnabledAtRuntime=ShadowDOM] readonly attribute boolean scoped;
    62     [InitializedByEventConstructor, EnabledAtRuntime=ShadowDOM] readonly attribute boolean relatedTargetScoped;
     61    [InitializedByEventConstructor, EnabledAtRuntime=ShadowDOM] readonly attribute boolean composed;
    6362    readonly attribute DOMTimeStamp     timeStamp;
    6463

  • trunk/Source/WebCore/dom/EventPath.cpp

    r202091 r202953  
    5151
    5252    bool targetIsInShadowRoot = targetNode && &targetNode->treeScope().rootNode() == &shadowRoot;
    53     return !targetIsInShadowRoot || !event.scoped();
     53    return !targetIsInShadowRoot || event.composed();
    5454}
    5555
    … …  
    8585
    8686EventPath::EventPath(Node& originalTarget, Event& event)
    87     : m_event(event)
    8887{
    8988    bool isMouseOrFocusEvent = event.isMouseEvent() || event.isFocusEvent();
    … …  
    142141
    143142    bool originIsRelatedTarget = &origin == relatedNode;
    144     bool relatedTargetScoped = m_event.relatedTargetScoped();
    145143    Node& rootNodeInOriginTreeScope = origin.treeScope().rootNode();
    146144    TreeScope* previousTreeScope = nullptr;
    … …  
    155153
    156154        Node* currentRelatedNode = retargeter.currentNode(currentTarget);
    157         if (UNLIKELY(relatedTargetScoped && !originIsRelatedTarget && context.target() == currentRelatedNode)) {
     155        if (UNLIKELY(!originIsRelatedTarget && context.target() == currentRelatedNode)) {
    158156            m_path.shrink(contextIndex);
    159157            break;
    … …  
    162160        context.setRelatedTarget(currentRelatedNode);
    163161
    164         if (UNLIKELY(relatedTargetScoped && originIsRelatedTarget && context.node() == &rootNodeInOriginTreeScope)) {
     162        if (UNLIKELY(originIsRelatedTarget && context.node() == &rootNodeInOriginTreeScope)) {
    165163            m_path.shrink(contextIndex + 1);
    166164            break;

  • trunk/Source/WebCore/dom/EventPath.h

    r200464 r202953  
    7070#endif
    7171
    72     Event& m_event;
    7372    Vector<std::unique_ptr<EventContext>, 32> m_path;
    7473};

  • trunk/Source/WebCore/dom/FocusEvent.cpp

    r198056 r202953  
    5353}
    5454
    55 bool FocusEvent::relatedTargetScoped() const
    56 {
    57     return (isTrusted() && m_relatedTarget) || UIEvent::relatedTargetScoped();
    58 }
    59 
    6055} // namespace WebCore

  • trunk/Source/WebCore/dom/FocusEvent.h

    r198056 r202953  
    5959    FocusEvent(const AtomicString& type, const FocusEventInit&);
    6060
    61     bool relatedTargetScoped() const override;
    62 
    6361    bool isFocusEvent() const override;
    6462

  • trunk/Source/WebCore/dom/MouseEvent.cpp

    r198056 r202953  
    190190}
    191191
    192 bool MouseEvent::relatedTargetScoped() const
    193 {
    194     return (isTrusted() && m_relatedTarget) || UIEvent::relatedTargetScoped();
    195 }
    196 
    197192int MouseEvent::which() const
    198193{

  • trunk/Source/WebCore/dom/MouseEvent.h

    r198056 r202953  
    122122    MouseEvent();
    123123
    124     bool relatedTargetScoped() const override;
    125 
    126124private:
    127125    unsigned short m_button;
Note: See TracChangeset for help on using the changeset viewer.