Changeset 201549 in webkit


Ignore:
Timestamp:
Jun 1, 2016 3:06:39 AM (8 years ago)
Author:
adam.bergkvist@ericsson.com
Message:

WebRTC: Add RTCRtpTransceiver interface and RTCPeerConnection.addTransceiver()
​https://bugs.webkit.org/show_bug.cgi?id=158189

Reviewed by Darin Adler.

Source/WebCore:

The RTCRtpTransceiver interface represents a combination of an RTCRtpSender and an
RTCRtpReceiver that share a common mid [1].

RTCPeerConnection.addTransceiver() [2] creates an RTCRtpTransceiver object, either directly
from a MediaStreamTrack [3], or with a specific media type (kind).

This change introduces the RTCRtpTransceiver object, follow-up patches will integrate it
into the offer/answer machinery.

[1] ​https://w3c.github.io/webrtc-pc/archives/20160513/webrtc.html#rtcrtptransceiver-interface
[2] ​https://w3c.github.io/webrtc-pc/archives/20160513/webrtc.html#dom-rtcpeerconnection-addtransceiver
[3] ​http://w3c.github.io/mediacapture-main/archives/20160513/getusermedia.html#mediastreamtrack

Test: fast/mediastream/RTCPeerConnection-addTransceiver.html

  • CMakeLists.txt:
  • Modules/mediastream/MediaEndpointPeerConnection.cpp:

(WebCore::MediaEndpointPeerConnection::createOfferTask):
(WebCore::MediaEndpointPeerConnection::createReceiver):
An RTCTransceiver always has a receiver (RTCRtpReceiver) with a track (MediaStreamTrack) that
can be rendered. Before that remote track is receiving data from the remote peer, it's muted.
createReceiver() uses MediaEndponit::createMutedRemoteSource() to create a source to represent
future incoming media.

  • Modules/mediastream/MediaEndpointPeerConnection.h:
  • Modules/mediastream/PeerConnectionBackend.h:
  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::addTransceiver):
(WebCore::RTCPeerConnection::completeAddTransceiver):
(WebCore::RTCPeerConnection::addReceiver): Deleted.
We now create the receiver explicitly with createReceiver.

  • Modules/mediastream/RTCPeerConnection.h:
  • Modules/mediastream/RTCPeerConnection.idl:
  • Modules/mediastream/RTCRtpSender.cpp:

(WebCore::RTCRtpSender::create):
(WebCore::RTCRtpSender::RTCRtpSender):
(WebCore::RTCRtpSender::setTrack):
(WebCore::RTCRtpSender::replaceTrack):

  • Modules/mediastream/RTCRtpSender.h:

(WebCore::RTCRtpSender::trackId):
(WebCore::RTCRtpSender::trackKind):
(WebCore::RTCRtpSender::setMediaStreamIds):
(WebCore::RTCRtpSender::isStopped):
(WebCore::RTCRtpSender::create): Deleted.

  • Modules/mediastream/RTCRtpSenderReceiverBase.h:

(WebCore::RTCRtpSenderReceiverBase::track):
(WebCore::RTCRtpSenderReceiverBase::RTCRtpSenderReceiverBase):

  • Modules/mediastream/RTCRtpTransceiver.cpp: Added.

(WebCore::RTCRtpTransceiver::create):
(WebCore::RTCRtpTransceiver::getNextMid):
(WebCore::RTCRtpTransceiver::RTCRtpTransceiver):
(WebCore::RTCRtpTransceiver::directionString):
(WebCore::RTCRtpTransceiver::hasSendingDirection):
(WebCore::RTCRtpTransceiver::enableSendingDirection):
(WebCore::RTCRtpTransceiver::disableSendingDirection):

  • Modules/mediastream/RTCRtpTransceiver.h: Added.

(WebCore::RTCRtpTransceiver::~RTCRtpTransceiver):
(WebCore::RTCRtpTransceiver::direction):
(WebCore::RTCRtpTransceiver::setDirection):
(WebCore::RTCRtpTransceiver::provisionalMid):
(WebCore::RTCRtpTransceiver::setProvisionalMid):
(WebCore::RTCRtpTransceiver::mid):
(WebCore::RTCRtpTransceiver::setMid):
(WebCore::RTCRtpTransceiver::sender):
(WebCore::RTCRtpTransceiver::receiver):
(WebCore::RTCRtpTransceiver::stopped):
(WebCore::RTCRtpTransceiver::stop):

  • Modules/mediastream/RTCRtpTransceiver.idl: Added.
  • WebCore.xcodeproj/project.pbxproj:
  • platform/mediastream/MediaEndpoint.h:

Added createMutedRemoteSource() that creates a muted remote source that will become unmuted
when media arrives from the remote peer.

  • platform/mediastream/RealtimeMediaSource.cpp:

(WebCore::RealtimeMediaSource::RealtimeMediaSource): Deleted.

  • platform/mediastream/RealtimeMediaSource.h:
  • platform/mediastream/mac/MockRealtimeVideoSourceMac.mm:

(WebCore::MockRealtimeVideoSource::create):
Use Ref instead of RefPtr.

  • platform/mock/MockMediaEndpoint.cpp:

(WebCore::MockMediaEndpoint::createMutedRemoteSource):

  • platform/mock/MockMediaEndpoint.h:
  • platform/mock/MockRealtimeAudioSource.cpp:

(WebCore::MockRealtimeAudioSource::create):
(WebCore::MockRealtimeAudioSource::createMuted):
(WebCore::MockRealtimeAudioSource::MockRealtimeAudioSource):

  • platform/mock/MockRealtimeAudioSource.h:
  • platform/mock/MockRealtimeVideoSource.cpp:

(WebCore::MockRealtimeVideoSource::create):
(WebCore::MockRealtimeVideoSource::createMuted):
(WebCore::MockRealtimeVideoSource::MockRealtimeVideoSource):

  • platform/mock/MockRealtimeVideoSource.h:

LayoutTests:

Added test for RTCPeerConnection.addTransceiver().

  • fast/mediastream/RTCPeerConnection-addTransceiver-expected.txt: Added.
  • fast/mediastream/RTCPeerConnection-addTransceiver.html: Added.

Test creating several RTCRtpTransceivers with various configurations and inspect the result.

  • platform/mac/TestExpectations:

Skip the new test since the Mac port currently doesn't build with WebRTC support.

Location:
trunk
Files:
3 added
24 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r201545 r201549  
     12016-06-01  Adam Bergkvist  <adam.bergkvist@ericsson.com>
     2
     3        WebRTC: Add RTCRtpTransceiver interface and RTCPeerConnection.addTransceiver()
     4        https://bugs.webkit.org/show_bug.cgi?id=158189
     5
     6        Reviewed by Darin Adler.
     7
     8        Added test for RTCPeerConnection.addTransceiver().
     9
     10        * fast/mediastream/RTCPeerConnection-addTransceiver-expected.txt: Added.
     11        * fast/mediastream/RTCPeerConnection-addTransceiver.html: Added.
     12        Test creating several RTCRtpTransceivers with various configurations and inspect the result.
     13        * platform/mac/TestExpectations:
     14        Skip the new test since the Mac port currently doesn't build with WebRTC support.
     15
    1162016-06-01  Manuel Rego Casasnovas  <rego@igalia.com>
    217

  • trunk/LayoutTests/platform/mac/TestExpectations

    r201522 r201549  
    188188fast/mediastream/RTCPeerConnection-overloaded-operations-params.html
    189189fast/mediastream/RTCPeerConnection-overloaded-operations.html
     190fast/mediastream/RTCPeerConnection-addTransceiver.html
    190191fast/mediastream/RTCRtpSender-replaceTrack.html
    191192fast/mediastream/RTCSessionDescription.html

  • trunk/Source/WebCore/CMakeLists.txt

    r201504 r201549  
    236236    Modules/mediastream/RTCRtpReceiver.idl
    237237    Modules/mediastream/RTCRtpSender.idl
     238    Modules/mediastream/RTCRtpTransceiver.idl
    238239    Modules/mediastream/RTCSessionDescription.idl
    239240    Modules/mediastream/RTCStatsReport.idl
    … …  
    931932    Modules/mediastream/RTCRtpReceiver.cpp
    932933    Modules/mediastream/RTCRtpSender.cpp
     934    Modules/mediastream/RTCRtpTransceiver.cpp
    933935    Modules/mediastream/RTCSessionDescription.cpp
    934936    Modules/mediastream/RTCStatsReport.cpp

  • trunk/Source/WebCore/ChangeLog

    r201547 r201549  
     12016-06-01  Adam Bergkvist  <adam.bergkvist@ericsson.com>
     2
     3        WebRTC: Add RTCRtpTransceiver interface and RTCPeerConnection.addTransceiver()
     4        https://bugs.webkit.org/show_bug.cgi?id=158189
     5
     6        Reviewed by Darin Adler.
     7
     8        The RTCRtpTransceiver interface represents a combination of an RTCRtpSender and an
     9        RTCRtpReceiver that share a common mid [1].
     10
     11        RTCPeerConnection.addTransceiver() [2] creates an RTCRtpTransceiver object, either directly
     12        from a MediaStreamTrack [3], or with a specific media type (kind).
     13
     14        This change introduces the RTCRtpTransceiver object, follow-up patches will integrate it
     15        into the offer/answer machinery.
     16
     17        [1] https://w3c.github.io/webrtc-pc/archives/20160513/webrtc.html#rtcrtptransceiver-interface
     18        [2] https://w3c.github.io/webrtc-pc/archives/20160513/webrtc.html#dom-rtcpeerconnection-addtransceiver
     19        [3] http://w3c.github.io/mediacapture-main/archives/20160513/getusermedia.html#mediastreamtrack
     20
     21        Test: fast/mediastream/RTCPeerConnection-addTransceiver.html
     22
     23        * CMakeLists.txt:
     24        * Modules/mediastream/MediaEndpointPeerConnection.cpp:
     25        (WebCore::MediaEndpointPeerConnection::createOfferTask):
     26        (WebCore::MediaEndpointPeerConnection::createReceiver):
     27        An RTCTransceiver always has a receiver (RTCRtpReceiver) with a track (MediaStreamTrack) that
     28        can be rendered. Before that remote track is receiving data from the remote peer, it's muted.
     29        createReceiver() uses MediaEndponit::createMutedRemoteSource() to create a source to represent
     30        future incoming media.
     31        * Modules/mediastream/MediaEndpointPeerConnection.h:
     32        * Modules/mediastream/PeerConnectionBackend.h:
     33        * Modules/mediastream/RTCPeerConnection.cpp:
     34        (WebCore::RTCPeerConnection::addTransceiver):
     35        (WebCore::RTCPeerConnection::completeAddTransceiver):
     36        (WebCore::RTCPeerConnection::addReceiver): Deleted.
     37        We now create the receiver explicitly with createReceiver.
     38        * Modules/mediastream/RTCPeerConnection.h:
     39        * Modules/mediastream/RTCPeerConnection.idl:
     40        * Modules/mediastream/RTCRtpSender.cpp:
     41        (WebCore::RTCRtpSender::create):
     42        (WebCore::RTCRtpSender::RTCRtpSender):
     43        (WebCore::RTCRtpSender::setTrack):
     44        (WebCore::RTCRtpSender::replaceTrack):
     45        * Modules/mediastream/RTCRtpSender.h:
     46        (WebCore::RTCRtpSender::trackId):
     47        (WebCore::RTCRtpSender::trackKind):
     48        (WebCore::RTCRtpSender::setMediaStreamIds):
     49        (WebCore::RTCRtpSender::isStopped):
     50        (WebCore::RTCRtpSender::create): Deleted.
     51        * Modules/mediastream/RTCRtpSenderReceiverBase.h:
     52        (WebCore::RTCRtpSenderReceiverBase::track):
     53        (WebCore::RTCRtpSenderReceiverBase::RTCRtpSenderReceiverBase):
     54        * Modules/mediastream/RTCRtpTransceiver.cpp: Added.
     55        (WebCore::RTCRtpTransceiver::create):
     56        (WebCore::RTCRtpTransceiver::getNextMid):
     57        (WebCore::RTCRtpTransceiver::RTCRtpTransceiver):
     58        (WebCore::RTCRtpTransceiver::directionString):
     59        (WebCore::RTCRtpTransceiver::hasSendingDirection):
     60        (WebCore::RTCRtpTransceiver::enableSendingDirection):
     61        (WebCore::RTCRtpTransceiver::disableSendingDirection):
     62        * Modules/mediastream/RTCRtpTransceiver.h: Added.
     63        (WebCore::RTCRtpTransceiver::~RTCRtpTransceiver):
     64        (WebCore::RTCRtpTransceiver::direction):
     65        (WebCore::RTCRtpTransceiver::setDirection):
     66        (WebCore::RTCRtpTransceiver::provisionalMid):
     67        (WebCore::RTCRtpTransceiver::setProvisionalMid):
     68        (WebCore::RTCRtpTransceiver::mid):
     69        (WebCore::RTCRtpTransceiver::setMid):
     70        (WebCore::RTCRtpTransceiver::sender):
     71        (WebCore::RTCRtpTransceiver::receiver):
     72        (WebCore::RTCRtpTransceiver::stopped):
     73        (WebCore::RTCRtpTransceiver::stop):
     74        * Modules/mediastream/RTCRtpTransceiver.idl: Added.
     75        * WebCore.xcodeproj/project.pbxproj:
     76        * platform/mediastream/MediaEndpoint.h:
     77        Added createMutedRemoteSource() that creates a muted remote source that will become unmuted
     78        when media arrives from the remote peer.
     79        * platform/mediastream/RealtimeMediaSource.cpp:
     80        (WebCore::RealtimeMediaSource::RealtimeMediaSource): Deleted.
     81        * platform/mediastream/RealtimeMediaSource.h:
     82        * platform/mediastream/mac/MockRealtimeVideoSourceMac.mm:
     83        (WebCore::MockRealtimeVideoSource::create):
     84        Use Ref instead of RefPtr.
     85        * platform/mock/MockMediaEndpoint.cpp:
     86        (WebCore::MockMediaEndpoint::createMutedRemoteSource):
     87        * platform/mock/MockMediaEndpoint.h:
     88        * platform/mock/MockRealtimeAudioSource.cpp:
     89        (WebCore::MockRealtimeAudioSource::create):
     90        (WebCore::MockRealtimeAudioSource::createMuted):
     91        (WebCore::MockRealtimeAudioSource::MockRealtimeAudioSource):
     92        * platform/mock/MockRealtimeAudioSource.h:
     93        * platform/mock/MockRealtimeVideoSource.cpp:
     94        (WebCore::MockRealtimeVideoSource::create):
     95        (WebCore::MockRealtimeVideoSource::createMuted):
     96        (WebCore::MockRealtimeVideoSource::MockRealtimeVideoSource):
     97        * platform/mock/MockRealtimeVideoSource.h:
     98
    1992016-06-01  Per Arne Vollan  <pvollan@apple.com>
    2100

  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.cpp

    r201493 r201549  
    3838#include "MediaStreamTrack.h"
    3939#include "RTCOfferAnswerOptions.h"
    40 #include "RTCRtpSender.h"
     40#include "RTCRtpTransceiver.h"
    4141#include "SDPProcessor.h"
    4242#include <wtf/MainThread.h>
    … …  
    138138    for (auto& sender : senders) {
    139139        RefPtr<PeerMediaDescription> mediaDescription = PeerMediaDescription::create();
    140         MediaStreamTrack& track = sender->track();
     140        MediaStreamTrack& track = *sender->track();
    141141
    142142        mediaDescription->setMediaStreamId(sender->mediaStreamIds()[0]);
    … …  
    256256}
    257257
     258RefPtr<RTCRtpReceiver> MediaEndpointPeerConnection::createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId)
     259{
     260    RealtimeMediaSource::Type sourceType = trackKind == "audio" ? RealtimeMediaSource::Type::Audio : RealtimeMediaSource::Type::Video;
     261
     262    // Create a muted remote source that will be unmuted once media starts arriving.
     263    auto remoteSource = m_mediaEndpoint->createMutedRemoteSource(transceiverMid, sourceType);
     264    auto remoteTrackPrivate = MediaStreamTrackPrivate::create(WTFMove(remoteSource), trackId);
     265    auto remoteTrack = MediaStreamTrack::create(*m_client->scriptExecutionContext(), *remoteTrackPrivate);
     266
     267    return RTCRtpReceiver::create(WTFMove(remoteTrack));
     268}
     269
    258270void MediaEndpointPeerConnection::replaceTrack(RTCRtpSender& sender, MediaStreamTrack& withTrack, PeerConnection::VoidPromise&& promise)
    259271{

  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.h

    r201493 r201549  
    7070    void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&) override;
    7171
     72    RefPtr<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) override;
    7273    void replaceTrack(RTCRtpSender&, MediaStreamTrack&, PeerConnection::VoidPromise&&) override;
    7374

  • trunk/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h

    r201013 r201549  
    4949class RTCRtpReceiver;
    5050class RTCRtpSender;
     51class RTCRtpTransceiver;
    5152class RTCSessionDescription;
    5253class RTCStatsResponse;
    … …  
    6465    virtual void fireEvent(Event&) = 0;
    6566
    66     virtual void addReceiver(RTCRtpReceiver&) = 0;
    6767    virtual void setSignalingState(PeerConnectionStates::SignalingState) = 0;
    6868    virtual void updateIceGatheringState(PeerConnectionStates::IceGatheringState) = 0;
    … …  
    104104    virtual void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&) = 0;
    105105
     106    virtual RefPtr<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) = 0;
    106107    virtual void replaceTrack(RTCRtpSender&, MediaStreamTrack&, PeerConnection::VoidPromise&&) = 0;
    107108

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r201080 r201549  
    5050#include "RTCSessionDescription.h"
    5151#include "RTCTrackEvent.h"
     52#include "UUID.h"
    5253#include <wtf/MainThread.h>
    5354#include <wtf/text/Base64.h>
    … …  
    146147
    147148    m_backend->markAsNeedingNegotiation();
     149}
     150
     151RefPtr<RTCRtpTransceiver> RTCPeerConnection::addTransceiver(Ref<MediaStreamTrack>&& track, const RtpTransceiverInit& init, ExceptionCode& ec)
     152{
     153    if (m_signalingState == SignalingState::Closed) {
     154        ec = INVALID_STATE_ERR;
     155        return nullptr;
     156    }
     157
     158    String transceiverMid = RTCRtpTransceiver::getNextMid();
     159    const String& trackKind = track->kind();
     160    const String& trackId = track->id();
     161
     162    auto sender = RTCRtpSender::create(WTFMove(track), Vector<String>(), *this);
     163    auto receiver = m_backend->createReceiver(transceiverMid, trackKind, trackId);
     164    auto transceiver = RTCRtpTransceiver::create(WTFMove(sender), WTFMove(receiver));
     165    transceiver->setProvisionalMid(transceiverMid);
     166
     167    return completeAddTransceiver(WTFMove(transceiver), init);
     168}
     169
     170RefPtr<RTCRtpTransceiver> RTCPeerConnection::addTransceiver(const String& kind, const RtpTransceiverInit& init, ExceptionCode& ec)
     171{
     172    if (m_signalingState == SignalingState::Closed) {
     173        ec = INVALID_STATE_ERR;
     174        return nullptr;
     175    }
     176
     177    if (kind != "audio" && kind != "video") {
     178        ec = TypeError;
     179        return nullptr;
     180    }
     181
     182    String transceiverMid = RTCRtpTransceiver::getNextMid();
     183    String trackId = createCanonicalUUIDString();
     184
     185    auto sender = RTCRtpSender::create(kind, Vector<String>(), *this);
     186    auto receiver = m_backend->createReceiver(transceiverMid, kind, trackId);
     187    auto transceiver = RTCRtpTransceiver::create(WTFMove(sender), WTFMove(receiver));
     188    transceiver->setProvisionalMid(transceiverMid);
     189
     190    return completeAddTransceiver(WTFMove(transceiver), init);
     191}
     192
     193RefPtr<RTCRtpTransceiver> RTCPeerConnection::completeAddTransceiver(Ref<RTCRtpTransceiver>&& transceiver, const RtpTransceiverInit& init)
     194{
     195    transceiver->setDirection(static_cast<RTCRtpTransceiver::Direction>(init.direction));
     196
     197    m_transceiverSet.append(transceiver.copyRef());
     198    m_backend->markAsNeedingNegotiation();
     199
     200    return WTFMove(transceiver);
    148201}
    149202
    … …  
    372425}
    373426
    374 void RTCPeerConnection::addReceiver(RTCRtpReceiver& receiver)
    375 {
    376     m_receiverSet.append(&receiver);
    377 }
    378 
    379427void RTCPeerConnection::setSignalingState(SignalingState newState)
    380428{

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r200246 r201549  
    4242#include "JSMediaStream.h"
    4343#include "PeerConnectionBackend.h"
    44 #include "RTCRtpReceiver.h"
    45 #include "RTCRtpSender.h"
     44#include "RTCRtpTransceiver.h"
    4645#include "ScriptWrappable.h"
    4746#include <wtf/HashMap.h>
    … …  
    6766    Vector<RefPtr<RTCRtpSender>> getSenders() const override { return m_senderSet; }
    6867    Vector<RefPtr<RTCRtpReceiver>> getReceivers() const { return m_receiverSet; }
     68    const Vector<RefPtr<RTCRtpTransceiver>>& getTransceivers() const { return m_transceiverSet; }
    6969
    7070    RefPtr<RTCRtpSender> addTrack(Ref<MediaStreamTrack>&&, Vector<MediaStream*>, ExceptionCode&);
    7171    void removeTrack(RTCRtpSender&, ExceptionCode&);
     72
     73    // This enum is mirrored in RTCRtpTransceiver.h
     74    enum class RtpTransceiverDirection { Sendrecv, Sendonly, Recvonly, Inactive };
     75
     76    struct RtpTransceiverInit {
     77        RtpTransceiverDirection direction;
     78    };
     79
     80    RefPtr<RTCRtpTransceiver> addTransceiver(Ref<MediaStreamTrack>&&, const RtpTransceiverInit&, ExceptionCode&);
     81    RefPtr<RTCRtpTransceiver> addTransceiver(const String& kind, const RtpTransceiverInit&, ExceptionCode&);
    7282
    7383    void queuedCreateOffer(const Dictionary& offerOptions, PeerConnection::SessionDescriptionPromise&&);
    … …  
    110120    RTCPeerConnection(ScriptExecutionContext&, RefPtr<RTCConfiguration>&&, ExceptionCode&);
    111121
     122    RefPtr<RTCRtpTransceiver> completeAddTransceiver(Ref<RTCRtpTransceiver>&&, const RtpTransceiverInit&);
     123
    112124    // EventTarget implementation.
    113125    void refEventTarget() override { ref(); }
    … …  
    120132
    121133    // PeerConnectionBackendClient
    122     void addReceiver(RTCRtpReceiver&) override;
    123134    void setSignalingState(PeerConnectionStates::SignalingState) override;
    124135    void updateIceGatheringState(PeerConnectionStates::IceGatheringState) override;
    … …  
    141152    Vector<RefPtr<RTCRtpSender>> m_senderSet;
    142153    Vector<RefPtr<RTCRtpReceiver>> m_receiverSet;
     154    Vector<RefPtr<RTCRtpTransceiver>> m_transceiverSet;
    143155
    144156    Vector<RefPtr<RTCDataChannel>> m_dataChannels;

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl

    r201455 r201549  
    6161    sequence<RTCRtpSender> getSenders();
    6262    sequence<RTCRtpReceiver> getReceivers();
     63    sequence<RTCRtpTransceiver> getTransceivers();
    6364
    6465    [StrictTypeChecking, RaisesException] RTCRtpSender addTrack(MediaStreamTrack track, MediaStream... streams);
    6566    [StrictTypeChecking, RaisesException] void removeTrack(RTCRtpSender sender);
     67
     68    [StrictTypeChecking, RaisesException] RTCRtpTransceiver addTransceiver(MediaStreamTrack track, optional RTCRtpTransceiverInit init);
     69    [StrictTypeChecking, RaisesException] RTCRtpTransceiver addTransceiver(DOMString kind, optional RTCRtpTransceiverInit init);
    6670
    6771    [JSBuiltin] Promise setLocalDescription(RTCSessionDescription description);
    … …  
    113117    attribute EventHandler ondatachannel;
    114118};
     119
     120// This enum is mirrored in RTCRtpTransceiver.idl
     121enum RTCRtpTransceiverDirection { "sendrecv", "sendonly", "recvonly", "inactive" };
     122
     123dictionary RTCRtpTransceiverInit {
     124    RTCRtpTransceiverDirection direction = "sendrecv";
     125};

  • trunk/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp

    r201080 r201549  
    3838namespace WebCore {
    3939
    40 RTCRtpSender::RTCRtpSender(Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
    41     : RTCRtpSenderReceiverBase(WTFMove(track))
     40Ref<RTCRtpSender> RTCRtpSender::create(Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
     41{
     42    const String& trackKind = track->kind();
     43    return adoptRef(*new RTCRtpSender(WTFMove(track), trackKind, WTFMove(mediaStreamIds), client));
     44}
     45
     46Ref<RTCRtpSender> RTCRtpSender::create(const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
     47{
     48    return adoptRef(*new RTCRtpSender(nullptr, trackKind, WTFMove(mediaStreamIds), client));
     49}
     50
     51RTCRtpSender::RTCRtpSender(RefPtr<MediaStreamTrack>&& track, const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
     52    : RTCRtpSenderReceiverBase()
     53    , m_trackKind(trackKind)
    4254    , m_mediaStreamIds(WTFMove(mediaStreamIds))
    4355    , m_client(&client)
    4456{
    45     // The original track id is always used in negotiation even if the track is replaced.
    46     m_trackId = m_track->id();
     57    setTrack(WTFMove(track));
    4758}
    4859
    49 void RTCRtpSender::replaceTrack(MediaStreamTrack& withTrack, PeerConnection::VoidPromise&& promise, ExceptionCode& ec)
     60void RTCRtpSender::setTrack(RefPtr<MediaStreamTrack>&& track)
    5061{
    51     if (!m_client) {
     62    // Save the id from the first non-null track set. That id will be used to negotiate the sender
     63    // even if the track is replaced.
     64    if (!m_track && track)
     65        m_trackId = track->id();
     66
     67    m_track = WTFMove(track);
     68}
     69
     70void RTCRtpSender::replaceTrack(Ref<MediaStreamTrack>&& withTrack, PeerConnection::VoidPromise&& promise, ExceptionCode& ec)
     71{
     72    if (isStopped()) {
    5273        promise.reject(INVALID_STATE_ERR);
    5374        return;
    5475    }
    5576
    56     if (m_track->kind() != withTrack.kind()) {
     77    if (m_trackKind != withTrack->kind()) {
    5778        ec = TypeError;
    5879        return;
    5980    }
    6081
    61     m_client->replaceTrack(*this, withTrack, WTFMove(promise));
     82    m_client->replaceTrack(*this, WTFMove(withTrack), WTFMove(promise));
    6283}
    6384

  • trunk/Source/WebCore/Modules/mediastream/RTCRtpSender.h

    r200231 r201549  
    4949class RTCRtpSender : public RTCRtpSenderReceiverBase {
    5050public:
    51     static Ref<RTCRtpSender> create(Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
    52     {
    53         return adoptRef(*new RTCRtpSender(WTFMove(track), WTFMove(mediaStreamIds), client));
    54     }
     51    static Ref<RTCRtpSender> create(Ref<MediaStreamTrack>&&, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
     52    static Ref<RTCRtpSender> create(const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
    5553
    56     const String& trackId() { return m_trackId; }
     54    const String& trackId() const { return m_trackId; }
     55    const String& trackKind() const { return m_trackKind; }
     56
    5757    const Vector<String>& mediaStreamIds() const { return m_mediaStreamIds; }
     58    void setMediaStreamIds(Vector<String>&& mediaStreamIds) { m_mediaStreamIds = WTFMove(mediaStreamIds); }
    5859
     60    bool isStopped() const { return !m_client; }
    5961    void stop() { m_client = nullptr; }
     62    void setTrack(RefPtr<MediaStreamTrack>&&);
    6063
    61     void replaceTrack(MediaStreamTrack&, PeerConnection::VoidPromise&&, ExceptionCode&);
     64    void replaceTrack(Ref<MediaStreamTrack>&&, PeerConnection::VoidPromise&&, ExceptionCode&);
    6265
    6366private:
    64     RTCRtpSender(Ref<MediaStreamTrack>&&, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
     67    RTCRtpSender(RefPtr<MediaStreamTrack>&&, const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
    6568
    6669    String m_trackId;
     70    String m_trackKind;
    6771    Vector<String> m_mediaStreamIds;
    6872    RTCRtpSenderClient* m_client;

  • trunk/Source/WebCore/Modules/mediastream/RTCRtpSenderReceiverBase.h

    r200231 r201549  
    4545class RTCRtpSenderReceiverBase : public RefCounted<RTCRtpSenderReceiverBase>, public ScriptWrappable {
    4646public:
    47     virtual ~RTCRtpSenderReceiverBase() { }
     47    virtual ~RTCRtpSenderReceiverBase() = default;
    4848
    49     MediaStreamTrack& track() { return m_track; }
     49    MediaStreamTrack* track() { return m_track.get(); }
    5050
    5151protected:
     52    RTCRtpSenderReceiverBase() = default;
     53
    5254    RTCRtpSenderReceiverBase(Ref<MediaStreamTrack>&& track)
    5355        : m_track(WTFMove(track))
    5456    { }
    5557
    56     Ref<MediaStreamTrack> m_track;
     58    RefPtr<MediaStreamTrack> m_track;
    5759};
    5860

  • trunk/Source/WebCore/Modules/mediastream/RTCRtpTransceiver.h

    r201548 r201549  
    11/*
    2  * Copyright (C) 2015 Ericsson AB. All rights reserved.
     2 * Copyright (C) 2016 Ericsson AB. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2929 */
    3030
    31 #ifndef RTCRtpSenderReceiverBase_h
    32 #define RTCRtpSenderReceiverBase_h
     31#ifndef RTCRtpTransceiver_h
     32#define RTCRtpTransceiver_h
    3333
    3434#if ENABLE(WEB_RTC)
    3535
    36 #include "MediaStreamTrack.h"
     36#include "RTCRtpReceiver.h"
     37#include "RTCRtpSender.h"
    3738#include "ScriptWrappable.h"
    3839#include <wtf/RefCounted.h>
    3940#include <wtf/RefPtr.h>
     41#include <wtf/text/WTFString.h>
    4042
    4143namespace WebCore {
    4244
    43 class MediaStreamTrack;
     45class RTCRtpTransceiver : public RefCounted<RTCRtpTransceiver>, public ScriptWrappable {
     46public:
     47    // This enum is mirrored in RTCPeerConnection.h
     48    enum class Direction { Sendrecv, Sendonly, Recvonly, Inactive };
    4449
    45 class RTCRtpSenderReceiverBase : public RefCounted<RTCRtpSenderReceiverBase>, public ScriptWrappable {
    46 public:
    47     virtual ~RTCRtpSenderReceiverBase() { }
     50    static Ref<RTCRtpTransceiver> create(RefPtr<RTCRtpSender>&&, RefPtr<RTCRtpReceiver>&&);
     51    virtual ~RTCRtpTransceiver() { }
    4852
    49     MediaStreamTrack& track() { return m_track; }
     53    bool hasSendingDirection() const;
     54    void enableSendingDirection();
     55    void disableSendingDirection();
    5056
    51 protected:
    52     RTCRtpSenderReceiverBase(Ref<MediaStreamTrack>&& track)
    53         : m_track(WTFMove(track))
    54     { }
     57    const String& directionString() const;
     58    Direction direction() const { return m_direction; }
     59    void setDirection(Direction direction) { m_direction = direction; }
    5560
    56     Ref<MediaStreamTrack> m_track;
     61    const String& provisionalMid() const { return m_provisionalMid; }
     62    void setProvisionalMid(const String& provisionalMid) { m_provisionalMid = provisionalMid; }
     63
     64    const String& mid() const { return m_mid; }
     65    void setMid(const String& mid) { m_mid = mid; }
     66
     67    RTCRtpSender* sender() const { return m_sender.get(); }
     68    RTCRtpReceiver* receiver() const { return m_receiver.get(); }
     69
     70    bool stopped() const { return m_stopped; }
     71    void stop() { m_stopped = true; }
     72
     73    static String getNextMid();
     74
     75private:
     76    RTCRtpTransceiver(RefPtr<RTCRtpSender>&&, RefPtr<RTCRtpReceiver>&&);
     77
     78    String m_provisionalMid;
     79    String m_mid;
     80
     81    Direction m_direction;
     82
     83    RefPtr<RTCRtpSender> m_sender;
     84    RefPtr<RTCRtpReceiver> m_receiver;
     85
     86    bool m_stopped { false };
    5787};
    5888
    … …  
    6191#endif // ENABLE(WEB_RTC)
    6292
    63 #endif // RTCRtpSenderReceiverBase_h
     93#endif // RTCRtpTransceiver_h

  • trunk/Source/WebCore/Modules/mediastream/RTCRtpTransceiver.idl

    r201548 r201549  
    11/*
    2  * Copyright (C) 2015 Ericsson AB. All rights reserved.
     2 * Copyright (C) 2016 Ericsson AB. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2929 */
    3030
    31 #ifndef RTCRtpSenderReceiverBase_h
    32 #define RTCRtpSenderReceiverBase_h
     31[
     32    Conditional=WEB_RTC
     33] interface RTCRtpTransceiver {
     34    readonly attribute DOMString? mid;
     35    readonly attribute RTCRtpSender sender;
     36    readonly attribute RTCRtpReceiver receiver;
     37    readonly attribute boolean stopped;
     38    readonly attribute RTCRtpTransceiverDirection direction;
    3339
    34 #if ENABLE(WEB_RTC)
    35 
    36 #include "MediaStreamTrack.h"
    37 #include "ScriptWrappable.h"
    38 #include <wtf/RefCounted.h>
    39 #include <wtf/RefPtr.h>
    40 
    41 namespace WebCore {
    42 
    43 class MediaStreamTrack;
    44 
    45 class RTCRtpSenderReceiverBase : public RefCounted<RTCRtpSenderReceiverBase>, public ScriptWrappable {
    46 public:
    47     virtual ~RTCRtpSenderReceiverBase() { }
    48 
    49     MediaStreamTrack& track() { return m_track; }
    50 
    51 protected:
    52     RTCRtpSenderReceiverBase(Ref<MediaStreamTrack>&& track)
    53         : m_track(WTFMove(track))
    54     { }
    55 
    56     Ref<MediaStreamTrack> m_track;
     40    void setDirection(RTCRtpTransceiverDirection direction);
     41    void stop();
    5742};
    5843
    59 } // namespace WebCore
    60 
    61 #endif // ENABLE(WEB_RTC)
    62 
    63 #endif // RTCRtpSenderReceiverBase_h
     44// This enum is mirrored in RTCPeerConnection.idl
     45enum RTCRtpTransceiverDirection { "sendrecv", "sendonly", "recvonly", "inactive" };

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r201534 r201549  
    23872387                5E2C437B1BCF9A570001E2BC /* RTCPeerConnectionBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 5E2C43761BCF9A0B0001E2BC /* RTCPeerConnectionBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
    23882388                5E2C437C1BCF9A840001E2BC /* RTCPeerConnectionInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 5E2C43791BCF9A0B0001E2BC /* RTCPeerConnectionInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2389                5E5E2B131CFC3E70000C0D85 /* RTCRtpTransceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5E5E2B101CFC3E4B000C0D85 /* RTCRtpTransceiver.cpp */; };
     2390                5E5E2B141CFC3E75000C0D85 /* RTCRtpTransceiver.h in Headers */ = {isa = PBXBuildFile; fileRef = 5E5E2B111CFC3E4B000C0D85 /* RTCRtpTransceiver.h */; settings = {ATTRIBUTES = (Private, ); }; };
    23892391                5EA3D6DF1C859D7F00300BBB /* MockMediaEndpoint.h in Headers */ = {isa = PBXBuildFile; fileRef = 5EA3D6DE1C859D5300300BBB /* MockMediaEndpoint.h */; };
    23902392                5EA3D6E01C859D8400300BBB /* MockMediaEndpoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5EA3D6DD1C859D5300300BBB /* MockMediaEndpoint.cpp */; };
    … …  
    99929994                5E2C43781BCF9A0B0001E2BC /* RTCPeerConnectionInternalsBuiltins.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RTCPeerConnectionInternalsBuiltins.cpp; sourceTree = "<group>"; };
    99939995                5E2C43791BCF9A0B0001E2BC /* RTCPeerConnectionInternalsBuiltins.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCPeerConnectionInternalsBuiltins.h; sourceTree = "<group>"; };
     9996                5E5E2B101CFC3E4B000C0D85 /* RTCRtpTransceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RTCRtpTransceiver.cpp; sourceTree = "<group>"; };
     9997                5E5E2B111CFC3E4B000C0D85 /* RTCRtpTransceiver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCRtpTransceiver.h; sourceTree = "<group>"; };
     9998                5E5E2B121CFC3E4B000C0D85 /* RTCRtpTransceiver.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCRtpTransceiver.idl; sourceTree = "<group>"; };
    99949999                5EA3D6DD1C859D5300300BBB /* MockMediaEndpoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MockMediaEndpoint.cpp; sourceTree = "<group>"; };
    999510000                5EA3D6DE1C859D5300300BBB /* MockMediaEndpoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MockMediaEndpoint.h; sourceTree = "<group>"; };
    … …  
    1547315478                                5E2C435B1BCEE30D0001E2BC /* RTCRtpSender.idl */,
    1547415479                                5E2C435D1BCEE30D0001E2BC /* RTCRtpSenderReceiverBase.h */,
     15480                                5E5E2B101CFC3E4B000C0D85 /* RTCRtpTransceiver.cpp */,
     15481                                5E5E2B111CFC3E4B000C0D85 /* RTCRtpTransceiver.h */,
     15482                                5E5E2B121CFC3E4B000C0D85 /* RTCRtpTransceiver.idl */,
    1547515483                                07221B7A17CEC32700848E51 /* RTCSessionDescription.cpp */,
    1547615484                                07221B7B17CEC32700848E51 /* RTCSessionDescription.h */,
    … …  
    2718527193                                07A6D1EC1491137700051D0C /* MediaFragmentURIParser.h in Headers */,
    2718627194                                A8EA800E0A19516E00A8EF5F /* MediaList.h in Headers */,
     27195                                5E5E2B141CFC3E75000C0D85 /* RTCRtpTransceiver.h in Headers */,
    2718727196                                5EBB89311C7777FF00C65D41 /* MediaPayload.h in Headers */,
    2718827197                                07E3DFD11A9E786500764CA8 /* MediaPlaybackTarget.h in Headers */,
    … …  
    3094830957                                DEBCCDD516646EB200A452E1 /* MediaControlElementTypes.cpp in Sources */,
    3094930958                                CD27F6E7145770D30078207D /* MediaController.cpp in Sources */,
     30959                                5E5E2B131CFC3E70000C0D85 /* RTCRtpTransceiver.cpp in Sources */,
    3095030960                                1F3C3BEA135CAF3C00B8C1AC /* MediaControls.cpp in Sources */,
    3095130961                                4157AF8112F1FB0400A8C6F5 /* MediaControlsApple.cpp in Sources */,

  • trunk/Source/WebCore/platform/mediastream/MediaEndpoint.h

    r198492 r201549  
    3535
    3636#include "MediaEndpointConfiguration.h"
     37#include "RealtimeMediaSource.h"
    3738#include <wtf/text/WTFString.h>
    3839
    … …  
    7980    virtual void addRemoteCandidate(IceCandidate&, unsigned mdescIndex, const String& ufrag, const String& password) = 0;
    8081
     82    virtual Ref<RealtimeMediaSource> createMutedRemoteSource(const String& mid, RealtimeMediaSource::Type) = 0;
    8183    virtual void replaceSendSource(RealtimeMediaSource&, unsigned mdescIndex) = 0;
    8284

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSource.cpp

    r192954 r201549  
    4646    , m_type(type)
    4747    , m_name(name)
    48     , m_stopped(false)
    49     , m_muted(false)
    50     , m_readonly(false)
    51     , m_remote(false)
    52     , m_fitnessScore(0)
    5348{
    5449    // FIXME(147205): Need to implement fitness score for constraints

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSource.h

    r192954 r201549  
    121121    RealtimeMediaSource(const String& id, Type, const String& name);
    122122
     123    bool m_muted { false };
     124
    123125private:
    124126    String m_id;
    … …  
    126128    Type m_type;
    127129    String m_name;
    128     bool m_stopped;
     130    bool m_stopped { false };
    129131    Vector<Observer*> m_observers;
    130132
    131     bool m_muted;
    132     bool m_readonly;
    133     bool m_remote;
     133    bool m_readonly { false };
     134    bool m_remote { false };
    134135   
    135     unsigned m_fitnessScore;
     136    unsigned m_fitnessScore { 0 };
    136137};
    137138

  • trunk/Source/WebCore/platform/mediastream/mac/MockRealtimeVideoSourceMac.mm

    r192954 r201549  
    4545namespace WebCore {
    4646
    47 RefPtr<MockRealtimeVideoSource> MockRealtimeVideoSource::create()
     47Ref<MockRealtimeVideoSource> MockRealtimeVideoSource::create()
    4848{
    49     return adoptRef(new MockRealtimeVideoSourceMac());
     49    return adoptRef(*new MockRealtimeVideoSourceMac());
    5050}
    5151

  • trunk/Source/WebCore/platform/mock/MockMediaEndpoint.cpp

    r198492 r201549  
    3535
    3636#include "MediaPayload.h"
     37#include "MockRealtimeAudioSource.h"
     38#include "MockRealtimeVideoSource.h"
    3739#include <wtf/MainThread.h>
    3840
    … …  
    154156}
    155157
     158Ref<RealtimeMediaSource> MockMediaEndpoint::createMutedRemoteSource(const String&, RealtimeMediaSource::Type type)
     159{
     160    if (type == RealtimeMediaSource::Audio)
     161        return MockRealtimeAudioSource::createMuted("remote audio");
     162
     163    ASSERT(type == RealtimeMediaSource::Video);
     164    return MockRealtimeVideoSource::createMuted("remote video");
     165}
     166
    156167void MockMediaEndpoint::replaceSendSource(RealtimeMediaSource& newSource, unsigned mdescIndex)
    157168{

  • trunk/Source/WebCore/platform/mock/MockMediaEndpoint.h

    r198492 r201549  
    5656    void addRemoteCandidate(IceCandidate&, unsigned mdescIndex, const String& ufrag, const String& password) override;
    5757
     58    Ref<RealtimeMediaSource> createMutedRemoteSource(const String& mid, RealtimeMediaSource::Type) override;
    5859    void replaceSendSource(RealtimeMediaSource&, unsigned mdescIndex) override;
    5960

  • trunk/Source/WebCore/platform/mock/MockRealtimeAudioSource.cpp

    r193389 r201549  
    4141namespace WebCore {
    4242
    43 RefPtr<MockRealtimeAudioSource> MockRealtimeAudioSource::create()
     43Ref<MockRealtimeAudioSource> MockRealtimeAudioSource::create()
    4444{
    45     return adoptRef(new MockRealtimeAudioSource());
     45    return adoptRef(*new MockRealtimeAudioSource(MockRealtimeMediaSource::mockAudioSourceName()));
    4646}
    4747
    48 MockRealtimeAudioSource::MockRealtimeAudioSource()
    49     : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Audio, mockAudioSourceName())
     48Ref<MockRealtimeAudioSource> MockRealtimeAudioSource::createMuted(const String& name)
     49{
     50    auto source = adoptRef(*new MockRealtimeAudioSource(name));
     51    source->m_muted = true;
     52    return source;
     53}
     54
     55MockRealtimeAudioSource::MockRealtimeAudioSource(const String& name)
     56    : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Audio, name)
    5057{
    5158}

  • trunk/Source/WebCore/platform/mock/MockRealtimeAudioSource.h

    r192954 r201549  
    4444public:
    4545
    46     static RefPtr<MockRealtimeAudioSource> create();
     46    static Ref<MockRealtimeAudioSource> create();
     47    static Ref<MockRealtimeAudioSource> createMuted(const String& name);
    4748
    4849    virtual ~MockRealtimeAudioSource() { }
    4950
    5051protected:
    51     MockRealtimeAudioSource();
     52    MockRealtimeAudioSource(const String& name = ASCIILiteral("Mock audio device"));
    5253
    5354private:

  • trunk/Source/WebCore/platform/mock/MockRealtimeVideoSource.cpp

    r195244 r201549  
    5050
    5151#if !PLATFORM(MAC) && !PLATFORM(IOS)
    52 RefPtr<MockRealtimeVideoSource> MockRealtimeVideoSource::create()
    53 {
    54     return adoptRef(new MockRealtimeVideoSource());
     52Ref<MockRealtimeVideoSource> MockRealtimeVideoSource::create()
     53{
     54    return adoptRef(*new MockRealtimeVideoSource(MockRealtimeMediaSource::mockVideoSourceName()));
     55}
     56
     57Ref<MockRealtimeVideoSource> MockRealtimeVideoSource::createMuted(const String& name)
     58{
     59    auto source = adoptRef(*new MockRealtimeVideoSource(name));
     60    source->m_muted = true;
     61    return source;
    5562}
    5663#endif
    5764
    58 MockRealtimeVideoSource::MockRealtimeVideoSource()
    59     : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Video, mockVideoSourceName())
     65MockRealtimeVideoSource::MockRealtimeVideoSource(const String& name)
     66    : MockRealtimeMediaSource(createCanonicalUUIDString(), RealtimeMediaSource::Video, name)
    6067    , m_timer(RunLoop::current(), this, &MockRealtimeVideoSource::generateFrame)
    6168{

  • trunk/Source/WebCore/platform/mock/MockRealtimeVideoSource.h

    r192954 r201549  
    4747public:
    4848
    49     static RefPtr<MockRealtimeVideoSource> create();
     49    static Ref<MockRealtimeVideoSource> create();
     50    static Ref<MockRealtimeVideoSource> createMuted(const String& name);
    5051
    5152    virtual ~MockRealtimeVideoSource() { }
    … …  
    5758
    5859protected:
    59     MockRealtimeVideoSource();
     60    MockRealtimeVideoSource(const String& name = ASCIILiteral("Mock video device"));
    6061    virtual void updatePlatformLayer() const { }
    6162
Note: See TracChangeset for help on using the changeset viewer.