Changeset 207175 in webkit


Ignore:
Timestamp:
Oct 11, 2016 4:11:49 PM (7 years ago)
Author:
Chris Dumez
Message:

Update MediaStream events to stop using legacy [ConstructorTemplate=Event]
https://bugs.webkit.org/show_bug.cgi?id=163289

Reviewed by Sam Weinig.

Source/WebCore:

Update MediaStream events to stop using legacy [ConstructorTemplate=Event]
and use regular constructors instead.

  • Modules/mediastream/MediaStreamEvent.cpp:

(WebCore::MediaStreamEvent::create):
(WebCore::MediaStreamEvent::MediaStreamEvent):

  • Modules/mediastream/MediaStreamEvent.h:
  • Modules/mediastream/MediaStreamEvent.idl:
  • Modules/mediastream/MediaStreamTrackEvent.cpp:

(WebCore::MediaStreamTrackEvent::create):
(WebCore::MediaStreamTrackEvent::MediaStreamTrackEvent):

  • Modules/mediastream/MediaStreamTrackEvent.h:
  • Modules/mediastream/MediaStreamTrackEvent.idl:
  • Modules/mediastream/OverconstrainedErrorEvent.h:

(WebCore::OverconstrainedErrorEvent::create):
(WebCore::OverconstrainedErrorEvent::OverconstrainedErrorEvent):
(WebCore::OverconstrainedErrorEvent::~OverconstrainedErrorEvent): Deleted.

  • Modules/mediastream/OverconstrainedErrorEvent.idl:
  • Modules/mediastream/RTCDTMFToneChangeEvent.cpp:

(WebCore::RTCDTMFToneChangeEvent::create):
(WebCore::RTCDTMFToneChangeEvent::RTCDTMFToneChangeEvent):

  • Modules/mediastream/RTCDTMFToneChangeEvent.h:
  • Modules/mediastream/RTCDTMFToneChangeEvent.idl:
  • Modules/mediastream/RTCTrackEvent.cpp:

(WebCore::RTCTrackEvent::create):
(WebCore::RTCTrackEvent::RTCTrackEvent):

  • Modules/mediastream/RTCTrackEvent.h:
  • Modules/mediastream/RTCTrackEvent.idl:

LayoutTests:

Update existing test cases now that we throw more exceptions on bad input.

  • fast/events/constructors/overconstrained-error-event-constructor-expected.txt:
  • fast/events/constructors/overconstrained-error-event-constructor.html:
  • fast/mediastream/MediaStreamTrackEvent-constructor-expected.txt:
  • fast/mediastream/MediaStreamTrackEvent-constructor.html:
Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r207173 r207175  
     12016-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Update MediaStream events to stop using legacy [ConstructorTemplate=Event]
     4        https://bugs.webkit.org/show_bug.cgi?id=163289
     5
     6        Reviewed by Sam Weinig.
     7
     8        Update existing test cases now that we throw more exceptions on bad input.
     9
     10        * fast/events/constructors/overconstrained-error-event-constructor-expected.txt:
     11        * fast/events/constructors/overconstrained-error-event-constructor.html:
     12        * fast/mediastream/MediaStreamTrackEvent-constructor-expected.txt:
     13        * fast/mediastream/MediaStreamTrackEvent-constructor.html:
     14
    1152016-10-11  Dean Jackson  <dino@apple.com>
    216
  • trunk/LayoutTests/fast/events/constructors/overconstrained-error-event-constructor-expected.txt

    r205024 r207175  
    1616PASS new OverconstrainedErrorEvent('eventType', { error: new OverconstrainedError('fred', 'unsupported constraint') }).error.message is "unsupported constraint"
    1717PASS new OverconstrainedErrorEvent('eventType', { error: null }).reason is undefined.
    18 PASS new OverconstrainedErrorEvent('eventType', { error: 'fake error' }).error is null
    19 PASS new OverconstrainedErrorEvent('eventType', { error: [] }).error is null
     18PASS new OverconstrainedErrorEvent('eventType', { error: 'fake error' }) threw exception TypeError: Type error.
     19PASS new OverconstrainedErrorEvent('eventType', { error: [] }) threw exception TypeError: Type error.
    2020PASS new OverconstrainedErrorEvent('eventType', { bubbles: true, cancelable: true, error: new OverconstrainedError() }).bubbles is true
    2121PASS new OverconstrainedErrorEvent('eventType', { bubbles: true, cancelable: true, error: new OverconstrainedError() }).cancelable is true
  • trunk/LayoutTests/fast/events/constructors/overconstrained-error-event-constructor.html

    r205024 r207175  
    3636
    3737        shouldBeUndefined("new OverconstrainedErrorEvent('eventType', { error: null }).reason");
    38         shouldBeNull("new OverconstrainedErrorEvent('eventType', { error: 'fake error' }).error", null);
    39         shouldBeNull("new OverconstrainedErrorEvent('eventType', { error: [] }).error", null);
     38        shouldThrowErrorName("new OverconstrainedErrorEvent('eventType', { error: 'fake error' })", "TypeError");
     39        shouldThrowErrorName("new OverconstrainedErrorEvent('eventType', { error: [] })", "TypeError");
    4040
    4141        // All initializers are passed.
  • trunk/LayoutTests/fast/mediastream/MediaStreamTrackEvent-constructor-expected.txt

    r186081 r207175  
    2020
    2121*** Bubbles and cancelable true, invalid track ***
    22 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).bubbles is true
    23 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).cancelable is true
    24 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).track is null
     22PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }) threw exception TypeError: Type error.
    2523
    2624*** Initialize 'track' with a invalid values ***
    27 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 10 }).track is null
    28 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 'string' }).track is null
    29 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: emptyObject }).track is null
    30 PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: document }).track is null
     25PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 10 }) threw exception TypeError: Type error.
     26PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 'string' }) threw exception TypeError: Type error.
     27PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: emptyObject }) threw exception TypeError: Type error.
     28PASS new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: document }) threw exception TypeError: Type error.
    3129
    3230*** Bubbles and cancelable true, valid track ***
  • trunk/LayoutTests/fast/mediastream/MediaStreamTrackEvent-constructor.html

    r186081 r207175  
    3434   
    3535                debug("<br>*** Bubbles and cancelable true, invalid track ***");
    36                 shouldBe("new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).bubbles", "true");
    37                 shouldBe("new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).cancelable", "true");
    38                 shouldBeNull("new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack }).track");
     36                shouldThrowErrorName("new MediaStreamTrackEvent('MediaStreamTrackEvent', { bubbles: true, cancelable: true, track: MediaStreamTrack })", "TypeError");
    3937   
    4038                debug("<br>*** Initialize 'track' with a invalid values ***");
    41                 shouldBeNull("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 10 }).track");
    42                 shouldBeNull("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: \'string\' }).track");
     39                shouldThrowErrorName("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: 10 })", "TypeError");
     40                shouldThrowErrorName("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: \'string\' })", "TypeError");
    4341                emptyObject = { };
    44                 shouldBeNull("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: emptyObject }).track");
    45                 shouldBeNull("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: document }).track");
     42                shouldThrowErrorName("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: emptyObject })", "TypeError");
     43                shouldThrowErrorName("new MediaStreamTrackEvent('MediaStreamTrackEvent', { track: document })", "TypeError");
    4644
    4745                debug("<br>*** Bubbles and cancelable true, valid track ***");
  • trunk/Source/WebCore/ChangeLog

    r207174 r207175  
     12016-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Update MediaStream events to stop using legacy [ConstructorTemplate=Event]
     4        https://bugs.webkit.org/show_bug.cgi?id=163289
     5
     6        Reviewed by Sam Weinig.
     7
     8        Update MediaStream events to stop using legacy [ConstructorTemplate=Event]
     9        and use regular constructors instead.
     10
     11        * Modules/mediastream/MediaStreamEvent.cpp:
     12        (WebCore::MediaStreamEvent::create):
     13        (WebCore::MediaStreamEvent::MediaStreamEvent):
     14        * Modules/mediastream/MediaStreamEvent.h:
     15        * Modules/mediastream/MediaStreamEvent.idl:
     16        * Modules/mediastream/MediaStreamTrackEvent.cpp:
     17        (WebCore::MediaStreamTrackEvent::create):
     18        (WebCore::MediaStreamTrackEvent::MediaStreamTrackEvent):
     19        * Modules/mediastream/MediaStreamTrackEvent.h:
     20        * Modules/mediastream/MediaStreamTrackEvent.idl:
     21        * Modules/mediastream/OverconstrainedErrorEvent.h:
     22        (WebCore::OverconstrainedErrorEvent::create):
     23        (WebCore::OverconstrainedErrorEvent::OverconstrainedErrorEvent):
     24        (WebCore::OverconstrainedErrorEvent::~OverconstrainedErrorEvent): Deleted.
     25        * Modules/mediastream/OverconstrainedErrorEvent.idl:
     26        * Modules/mediastream/RTCDTMFToneChangeEvent.cpp:
     27        (WebCore::RTCDTMFToneChangeEvent::create):
     28        (WebCore::RTCDTMFToneChangeEvent::RTCDTMFToneChangeEvent):
     29        * Modules/mediastream/RTCDTMFToneChangeEvent.h:
     30        * Modules/mediastream/RTCDTMFToneChangeEvent.idl:
     31        * Modules/mediastream/RTCTrackEvent.cpp:
     32        (WebCore::RTCTrackEvent::create):
     33        (WebCore::RTCTrackEvent::RTCTrackEvent):
     34        * Modules/mediastream/RTCTrackEvent.h:
     35        * Modules/mediastream/RTCTrackEvent.idl:
     36
    1372016-10-11  Chris Dumez  <cdumez@apple.com>
    238
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamEvent.cpp

    r202625 r207175  
    3838}
    3939
    40 Ref<MediaStreamEvent> MediaStreamEvent::createForBindings(const AtomicString& type, const MediaStreamEventInit& initializer)
     40Ref<MediaStreamEvent> MediaStreamEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
    4141{
    42     return adoptRef(*new MediaStreamEvent(type, initializer));
     42    return adoptRef(*new MediaStreamEvent(type, initializer, isTrusted));
    4343}
    4444
     
    4949}
    5050
    51 MediaStreamEvent::MediaStreamEvent(const AtomicString& type, const MediaStreamEventInit& initializer)
    52     : Event(type, initializer)
     51MediaStreamEvent::MediaStreamEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
     52    : Event(type, initializer, isTrusted)
    5353    , m_stream(initializer.stream)
    5454{
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamEvent.h

    r202625 r207175  
    3434namespace WebCore {
    3535
    36 struct MediaStreamEventInit : public EventInit {
    37     RefPtr<MediaStream> stream;
    38 };
    39 
    4036class MediaStreamEvent : public Event {
    4137public:
     
    4339
    4440    static Ref<MediaStreamEvent> create(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<MediaStream>&&);
    45     static Ref<MediaStreamEvent> createForBindings(const AtomicString& type, const MediaStreamEventInit& initializer);
     41
     42    struct Init : EventInit {
     43        RefPtr<MediaStream> stream;
     44    };
     45    static Ref<MediaStreamEvent> create(const AtomicString& type, const Init& initializer, IsTrusted = IsTrusted::No);
    4646
    4747    MediaStream* stream() const;
     
    5151private:
    5252    MediaStreamEvent(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<MediaStream>&&);
    53     MediaStreamEvent(const AtomicString& type, const MediaStreamEventInit&);
     53    MediaStreamEvent(const AtomicString& type, const Init&, IsTrusted);
    5454
    5555    RefPtr<MediaStream> m_stream;
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamEvent.idl

    r202625 r207175  
    2525[
    2626    Conditional=WEB_RTC,
    27     ConstructorTemplate=Event
     27    Constructor(DOMString type, MediaStreamEventInit eventInitDict),
    2828] interface MediaStreamEvent : Event {
    29    [InitializedByEventConstructor] readonly attribute MediaStream stream;
     29    readonly attribute MediaStream? stream;
    3030};
    3131
     32dictionary MediaStreamEventInit : EventInit {
     33    MediaStream? stream = null;
     34};
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrackEvent.cpp

    r204239 r207175  
    3838}
    3939
    40 Ref<MediaStreamTrackEvent> MediaStreamTrackEvent::createForBindings(const AtomicString& type, const MediaStreamTrackEventInit& initializer)
     40Ref<MediaStreamTrackEvent> MediaStreamTrackEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
    4141{
    42     return adoptRef(*new MediaStreamTrackEvent(type, initializer));
     42    return adoptRef(*new MediaStreamTrackEvent(type, initializer, isTrusted));
    4343}
    4444
     
    4949}
    5050
    51 MediaStreamTrackEvent::MediaStreamTrackEvent(const AtomicString& type, const MediaStreamTrackEventInit& initializer)
    52     : Event(type, initializer)
     51MediaStreamTrackEvent::MediaStreamTrackEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
     52    : Event(type, initializer, isTrusted)
    5353    , m_track(initializer.track)
    5454{
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrackEvent.h

    r204239 r207175  
    3535class MediaStreamTrack;
    3636
    37 struct MediaStreamTrackEventInit : public EventInit {
    38     RefPtr<MediaStreamTrack> track;
    39 };
    40 
    4137class MediaStreamTrackEvent : public Event {
    4238public:
     
    4440
    4541    static Ref<MediaStreamTrackEvent> create(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<MediaStreamTrack>&&);
    46     static Ref<MediaStreamTrackEvent> createForBindings(const AtomicString& type, const MediaStreamTrackEventInit& initializer);
     42
     43    struct Init : EventInit {
     44        RefPtr<MediaStreamTrack> track;
     45    };
     46    static Ref<MediaStreamTrackEvent> create(const AtomicString& type, const Init&, IsTrusted = IsTrusted::No);
    4747
    4848    MediaStreamTrack* track() const;
     
    5353private:
    5454    MediaStreamTrackEvent(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<MediaStreamTrack>&&);
    55     MediaStreamTrackEvent(const AtomicString& type, const MediaStreamTrackEventInit&);
     55    MediaStreamTrackEvent(const AtomicString& type, const Init&, IsTrusted);
    5656
    5757    RefPtr<MediaStreamTrack> m_track;
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrackEvent.idl

    r156135 r207175  
    2525[
    2626    Conditional=MEDIA_STREAM,
    27     ConstructorTemplate=Event
     27    Constructor(DOMString type, optional MediaStreamTrackEventInit eventInitDict),
    2828] interface MediaStreamTrackEvent : Event {
    29    [InitializedByEventConstructor] readonly attribute MediaStreamTrack track;
     29    readonly attribute MediaStreamTrack? track;
    3030};
    3131
     32dictionary MediaStreamTrackEventInit : EventInit {
     33    // FIXME: The specification says that this member should be required and non-nullable.
     34    MediaStreamTrack? track = null;
     35};
  • trunk/Source/WebCore/Modules/mediastream/OverconstrainedErrorEvent.h

    r205024 r207175  
    3737namespace WebCore {
    3838
    39 struct OverconstrainedErrorEventInit : public EventInit {
    40     RefPtr<OverconstrainedError> error;
    41 };
    42 
    4339class OverconstrainedErrorEvent : public Event {
    4440public:
     
    5046    }
    5147
    52     static Ref<OverconstrainedErrorEvent> createForBindings(const AtomicString& type, const OverconstrainedErrorEventInit& initializer)
     48    struct Init : EventInit {
     49        RefPtr<OverconstrainedError> error;
     50    };
     51
     52    static Ref<OverconstrainedErrorEvent> create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted = IsTrusted::No)
    5353    {
    54         return adoptRef(*new OverconstrainedErrorEvent(type, initializer));
     54        return adoptRef(*new OverconstrainedErrorEvent(type, initializer, isTrusted));
    5555    }
    5656
     
    6464    {
    6565    }
    66     OverconstrainedErrorEvent(const AtomicString& type, const OverconstrainedErrorEventInit& initializer)
    67         : Event(type, initializer)
     66    OverconstrainedErrorEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
     67        : Event(type, initializer, isTrusted)
    6868        , m_error(initializer.error)
    6969    {
  • trunk/Source/WebCore/Modules/mediastream/OverconstrainedErrorEvent.idl

    r205024 r207175  
    2929[
    3030    Conditional=MEDIA_STREAM,
    31     ConstructorTemplate=Event,
     31    Constructor(DOMString type, optional OverconstrainedErrorEventInit eventInitDict),
    3232] interface OverconstrainedErrorEvent : Event {
    33    [InitializedByEventConstructor] readonly attribute OverconstrainedError? error;
     33    readonly attribute OverconstrainedError? error;
    3434};
    3535
     36dictionary OverconstrainedErrorEventInit : EventInit {
     37    OverconstrainedError? error = null;
     38};
  • trunk/Source/WebCore/Modules/mediastream/RTCDTMFToneChangeEvent.cpp

    r198492 r207175  
    3838}
    3939
    40 Ref<RTCDTMFToneChangeEvent> RTCDTMFToneChangeEvent::createForBindings(const AtomicString& type, const RTCDTMFToneChangeEventInit& initializer)
     40Ref<RTCDTMFToneChangeEvent> RTCDTMFToneChangeEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
    4141{
    42     ASSERT_UNUSED(type, type == eventNames().tonechangeEvent);
    43     return adoptRef(*new RTCDTMFToneChangeEvent(initializer));
     42    return adoptRef(*new RTCDTMFToneChangeEvent(type, initializer, isTrusted));
    4443}
    4544
     
    5049}
    5150
    52 RTCDTMFToneChangeEvent::RTCDTMFToneChangeEvent(const RTCDTMFToneChangeEventInit& initializer)
    53     : Event(eventNames().tonechangeEvent, initializer)
     51RTCDTMFToneChangeEvent::RTCDTMFToneChangeEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
     52    : Event(type, initializer, isTrusted)
    5453    , m_tone(initializer.tone)
    5554{
  • trunk/Source/WebCore/Modules/mediastream/RTCDTMFToneChangeEvent.h

    r198492 r207175  
    3434namespace WebCore {
    3535
    36 struct RTCDTMFToneChangeEventInit : public EventInit {
    37     String tone;
    38 };
    39 
    4036class RTCDTMFToneChangeEvent : public Event {
    4137public:
     
    4339
    4440    static Ref<RTCDTMFToneChangeEvent> create(const String& tone);
    45     static Ref<RTCDTMFToneChangeEvent> createForBindings(const AtomicString& type, const RTCDTMFToneChangeEventInit& initializer);
     41
     42    struct Init : EventInit {
     43        String tone;
     44    };
     45
     46    static Ref<RTCDTMFToneChangeEvent> create(const AtomicString& type, const Init&, IsTrusted = IsTrusted::No);
    4647
    4748    const String& tone() const;
     
    5152private:
    5253    explicit RTCDTMFToneChangeEvent(const String& tone);
    53     explicit RTCDTMFToneChangeEvent(const RTCDTMFToneChangeEventInit&);
     54    RTCDTMFToneChangeEvent(const AtomicString& type, const Init&, IsTrusted);
    5455
    5556    String m_tone;
  • trunk/Source/WebCore/Modules/mediastream/RTCDTMFToneChangeEvent.idl

    r198492 r207175  
    2525
    2626[
    27     NoInterfaceObject,
    2827    Conditional=WEB_RTC,
    29     ConstructorTemplate=Event
     28    Constructor(DOMString type, optional RTCDTMFToneChangeEventInit eventInitDict),
    3029] interface RTCDTMFToneChangeEvent : Event {
    31     [InitializedByEventConstructor] readonly attribute DOMString tone;
     30    readonly attribute DOMString tone;
    3231};
     32
     33dictionary RTCDTMFToneChangeEventInit : EventInit {
     34    DOMString tone = "";
     35};
  • trunk/Source/WebCore/Modules/mediastream/RTCTrackEvent.cpp

    r201851 r207175  
    4646}
    4747
    48 Ref<RTCTrackEvent> RTCTrackEvent::createForBindings(const AtomicString& type, const RTCTrackEventInit& initializer)
     48Ref<RTCTrackEvent> RTCTrackEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
    4949{
    50     return adoptRef(*new RTCTrackEvent(type, initializer));
     50    return adoptRef(*new RTCTrackEvent(type, initializer, isTrusted));
    5151}
    5252
     
    6060}
    6161
    62 RTCTrackEvent::RTCTrackEvent(const AtomicString& type, const RTCTrackEventInit& initializer)
    63     : Event(type, initializer)
     62RTCTrackEvent::RTCTrackEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
     63    : Event(type, initializer, isTrusted)
    6464    , m_receiver(initializer.receiver)
    6565    , m_track(initializer.track)
  • trunk/Source/WebCore/Modules/mediastream/RTCTrackEvent.h

    r201851 r207175  
    4646typedef Vector<RefPtr<MediaStream>> MediaStreamArray;
    4747
    48 struct RTCTrackEventInit : public EventInit {
    49     RefPtr<RTCRtpReceiver> receiver;
    50     RefPtr<MediaStreamTrack> track;
    51     MediaStreamArray streams;
    52     RefPtr<RTCRtpTransceiver> transceiver;
    53 };
    54 
    5548class RTCTrackEvent : public Event {
    5649public:
    5750    static Ref<RTCTrackEvent> create(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<RTCRtpReceiver>&&, RefPtr<MediaStreamTrack>&&, MediaStreamArray&&, RefPtr<RTCRtpTransceiver>&&);
    58     static Ref<RTCTrackEvent> createForBindings(const AtomicString& type, const RTCTrackEventInit&);
     51
     52    struct Init : EventInit {
     53        RefPtr<RTCRtpReceiver> receiver;
     54        RefPtr<MediaStreamTrack> track;
     55        MediaStreamArray streams;
     56        RefPtr<RTCRtpTransceiver> transceiver;
     57    };
     58    static Ref<RTCTrackEvent> create(const AtomicString& type, const Init&, IsTrusted = IsTrusted::No);
    5959
    6060    RTCRtpReceiver* receiver() const { return m_receiver.get(); }
     
    6767private:
    6868    RTCTrackEvent(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<RTCRtpReceiver>&&, RefPtr<MediaStreamTrack>&&, MediaStreamArray&&, RefPtr<RTCRtpTransceiver>&&);
    69     RTCTrackEvent(const AtomicString& type, const RTCTrackEventInit&);
     69    RTCTrackEvent(const AtomicString& type, const Init&, IsTrusted);
    7070
    7171    RefPtr<RTCRtpReceiver> m_receiver;
  • trunk/Source/WebCore/Modules/mediastream/RTCTrackEvent.idl

    r204336 r207175  
    3131[
    3232    Conditional=WEB_RTC,
    33     ConstructorTemplate=Event
     33    Constructor(DOMString type, optional RTCTrackEventInit eventInitDict),
    3434] interface RTCTrackEvent : Event {
    35    [InitializedByEventConstructor] readonly attribute RTCRtpReceiver receiver;
    36    [InitializedByEventConstructor] readonly attribute MediaStreamTrack track;
     35   [InitializedByEventConstructor] readonly attribute RTCRtpReceiver? receiver;
     36   [InitializedByEventConstructor] readonly attribute MediaStreamTrack? track;
    3737   [InitializedByEventConstructor] readonly attribute sequence<MediaStream> streams;
    38    [InitializedByEventConstructor] readonly attribute RTCRtpTransceiver transceiver;
     38   [InitializedByEventConstructor] readonly attribute RTCRtpTransceiver? transceiver;
    3939};
     40
     41dictionary RTCTrackEventInit : EventInit {
     42    sequence<MediaStream> streams = [];
     43
     44    // FIXME: The specification says that these members should be required and non-nullable.
     45    RTCRtpReceiver? receiver = null;
     46    MediaStreamTrack? track = null;
     47    RTCRtpTransceiver? transceiver = null;
     48};
Note: See TracChangeset for help on using the changeset viewer.